Files
coder/coderd/exp_chats_test.go
T
Mathias Fredriksson fe0b6e5de0 fix: take chat state from the stream only (#30478)
The chat page got a chat's messages, queue and status from three places:
REST pages, action responses and stream events. None of them had a
version, so the client could not tell which was newer and reconciled
them with rules of its own. A refetch or a response could replace newer
state from the stream, and a stream message that failed to parse lost
its events and left an error until a reload.

The server now returns snapshot_version on the newest messages page and
on stream events (#29662), which makes one copy enough. Each chat has a
store that loads the newest page once; after that, only stream events
and older pages change it. To reconnect, to return to a chat within five
minutes, or to recover from a failed parse, the client opens the stream
again at the highest version it applied. It refetches no messages, so no
response replaces what the stream set.

The client no longer reads messages or queue rows from action responses,
so a send, an edit or a queue change would show only once the stream
reports it. The store therefore shows the action's direct effect at the
click and keeps it until the stored state holds the result or the
request fails. It does not end at the next stream event of a kind,
because that event can report another change, and the user's change
would disappear and come back.

A sent message has no ID until the server creates it, so pending sends
are matched to new messages in click order, and a chat's send, edit and
queue requests run one at a time to keep that order. This assumes one
user in one client. A message from an agent, an automation or another
API client can end a pending send early, and the next stream event
corrects it.

The composer clears at the click, because the chat already shows the
sent message. It stays editable, so text typed during the request is
kept.

Closes CODAGT-903
2026-11-17 19:57:11 +02:00

20353 lines
731 KiB
Go

package coderd_test
import (
"bytes"
"context"
"crypto/sha256"
"database/sql"
"encoding/base64"
"encoding/json"
stderrors "errors"
"fmt"
"io"
"maps"
"mime"
"net/http"
"net/http/httptest"
"net/url"
"regexp"
"slices"
"strconv"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/go-jose/go-jose/v4/jwt"
"github.com/google/uuid"
"github.com/modelcontextprotocol/go-sdk/mcp"
"github.com/sqlc-dev/pqtype"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sync/errgroup"
"golang.org/x/sync/singleflight"
"golang.org/x/xerrors"
"cdr.dev/slog/v3/sloggers/slogtest"
aibclient "github.com/coder/coder/v2/aibridge/client"
"github.com/coder/coder/v2/coderd"
"github.com/coder/coder/v2/coderd/aibridge"
"github.com/coder/coder/v2/coderd/aibridgedtest"
"github.com/coder/coder/v2/coderd/audit"
"github.com/coder/coder/v2/coderd/coderdtest"
"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/database/dbfake"
"github.com/coder/coder/v2/coderd/database/dbgen"
"github.com/coder/coder/v2/coderd/database/dbtestutil"
"github.com/coder/coder/v2/coderd/database/dbtime"
dbpubsub "github.com/coder/coder/v2/coderd/database/pubsub"
"github.com/coder/coder/v2/coderd/externalauth"
"github.com/coder/coder/v2/coderd/httpapi/httperror"
"github.com/coder/coder/v2/coderd/jwtutils"
coderdpubsub "github.com/coder/coder/v2/coderd/pubsub"
"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/x/chatd"
"github.com/coder/coder/v2/coderd/x/chatd/chathooks"
"github.com/coder/coder/v2/coderd/x/chatd/chatprompt"
"github.com/coder/coder/v2/coderd/x/chatd/chatprovider"
"github.com/coder/coder/v2/coderd/x/chatd/chatstate"
"github.com/coder/coder/v2/coderd/x/chatd/chattest"
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/codersdk/x/agenthooks"
"github.com/coder/coder/v2/testutil"
"github.com/coder/serpent"
"github.com/coder/websocket"
"github.com/coder/websocket/wsjson"
)
func newChatTestOptions(
t testing.TB,
values *codersdk.DeploymentValues,
overrides ...func(*coderdtest.Options),
) *coderdtest.Options {
t.Helper()
// Enable experiment-gated chat endpoints in tests.
if len(values.Experiments) == 0 {
values.Experiments = serpent.StringArray{
string(codersdk.ExperimentChatVirtualDesktop),
string(codersdk.ExperimentAgentLifecycleHooks),
string(codersdk.ExperimentChatInlineMCPServers),
}
}
opts := &coderdtest.Options{
DeploymentValues: values,
}
for _, override := range overrides {
override(opts)
}
return opts
}
func newChatClient(t testing.TB, overrides ...func(*coderdtest.Options)) *codersdk.ExperimentalClient {
t.Helper()
opts := newChatTestOptions(t, coderdtest.DeploymentValues(t), overrides...)
client, _, api := coderdtest.NewWithAPI(t, opts)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
return codersdk.NewExperimentalClient(client)
}
func newChatClientWithAPI(t testing.TB, overrides ...func(*coderdtest.Options)) (*codersdk.ExperimentalClient, *coderd.API) {
t.Helper()
opts := newChatTestOptions(t, coderdtest.DeploymentValues(t), overrides...)
client, _, api := coderdtest.NewWithAPI(t, opts)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
return codersdk.NewExperimentalClient(client), api
}
func newChatClientWithDeploymentValues(
t testing.TB,
values *codersdk.DeploymentValues,
) *codersdk.ExperimentalClient {
t.Helper()
opts := newChatTestOptions(t, values)
client, _, api := coderdtest.NewWithAPI(t, opts)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
return codersdk.NewExperimentalClient(client)
}
func newChatClientWithDatabase(t testing.TB, overrides ...func(*coderdtest.Options)) (*codersdk.ExperimentalClient, database.Store) {
t.Helper()
opts := newChatTestOptions(t, coderdtest.DeploymentValues(t), overrides...)
client, _, api := coderdtest.NewWithAPI(t, opts)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
return codersdk.NewExperimentalClient(client), api.Database
}
func newChatClientWithAPIAndDatabase(t testing.TB, overrides ...func(*coderdtest.Options)) (*codersdk.ExperimentalClient, database.Store, *coderd.API) {
t.Helper()
opts := newChatTestOptions(t, coderdtest.DeploymentValues(t), overrides...)
client, _, api := coderdtest.NewWithAPI(t, opts)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
return codersdk.NewExperimentalClient(client), api.Database, api
}
func newChatClientWithoutAIBridge(t testing.TB, overrides ...func(*coderdtest.Options)) (*codersdk.ExperimentalClient, database.Store, *coderd.API) {
t.Helper()
opts := newChatTestOptions(t, coderdtest.DeploymentValues(t), overrides...)
client, _, api := coderdtest.NewWithAPI(t, opts)
return codersdk.NewExperimentalClient(client), api.Database, api
}
func insertTestChatQueuedMessage(
ctx context.Context,
t testing.TB,
db database.Store,
chatID uuid.UUID,
content json.RawMessage,
modelConfigID uuid.UUID,
) database.ChatQueuedMessage {
t.Helper()
return insertTestChatQueuedMessageWithReasoningEffort(ctx, t, db, chatID, content, modelConfigID, "")
}
func insertTestChatQueuedMessageWithReasoningEffort(
ctx context.Context,
t testing.TB,
db database.Store,
chatID uuid.UUID,
content json.RawMessage,
modelConfigID uuid.UUID,
reasoningEffort string,
) database.ChatQueuedMessage {
t.Helper()
chat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chatID)
require.NoError(t, err)
queued, err := db.InsertChatQueuedMessageWithCreator(
dbauthz.AsSystemRestricted(ctx),
database.InsertChatQueuedMessageWithCreatorParams{
ChatID: chatID,
Content: content,
ModelConfigID: uuid.NullUUID{UUID: modelConfigID, Valid: modelConfigID != uuid.Nil},
ReasoningEffort: database.NullChatReasoningEffort{ChatReasoningEffort: database.ChatReasoningEffort(reasoningEffort), Valid: reasoningEffort != ""},
CreatedBy: chat.OwnerID,
BusyBehavior: database.ChatBusyBehaviorQueue,
},
)
require.NoError(t, err)
return queued
}
// findUserMessage returns the first user-role message from a slice of chat
// messages, failing the test if none is found.
func findUserMessage(t testing.TB, messages []database.ChatMessage) database.ChatMessage {
t.Helper()
idx := slices.IndexFunc(messages, func(m database.ChatMessage) bool {
return m.Role == database.ChatMessageRoleUser
})
require.NotEqual(t, -1, idx, "expected to find a user message")
return messages[idx]
}
// failNextChatSystemPromptStore lets a test force single chat system prompt
// queries to fail. One-shot flags disarm when the forced failure fires, and
// armed counters fail every matching read until the armed count reaches zero.
// Flags and counters are shared across InTx wrappers.
type failNextChatSystemPromptStore struct {
database.Store
failNextGetChatIncludeDefaultSystemPrompt *atomic.Bool
failNextGetChatSystemPromptConfig *atomic.Bool
armedGetChatSystemPromptConfigFailures *atomic.Int64
getChatSystemPromptConfigCallsBeforeFailure *atomic.Int64
failNextUpsertChatIncludeDefaultSystemPrompt *atomic.Bool
failNextGetChatOrganizationSystemPrompt *atomic.Bool
}
func newFailNextChatSystemPromptStore(store database.Store) *failNextChatSystemPromptStore {
return &failNextChatSystemPromptStore{
Store: store,
failNextGetChatIncludeDefaultSystemPrompt: &atomic.Bool{},
failNextGetChatSystemPromptConfig: &atomic.Bool{},
armedGetChatSystemPromptConfigFailures: &atomic.Int64{},
getChatSystemPromptConfigCallsBeforeFailure: &atomic.Int64{},
failNextUpsertChatIncludeDefaultSystemPrompt: &atomic.Bool{},
failNextGetChatOrganizationSystemPrompt: &atomic.Bool{},
}
}
func (s *failNextChatSystemPromptStore) InTx(function func(database.Store) error, txOpts *database.TxOptions) error {
return s.Store.InTx(func(tx database.Store) error {
return function(&failNextChatSystemPromptStore{
Store: tx,
failNextGetChatSystemPromptConfig: s.failNextGetChatSystemPromptConfig,
armedGetChatSystemPromptConfigFailures: s.armedGetChatSystemPromptConfigFailures,
getChatSystemPromptConfigCallsBeforeFailure: s.getChatSystemPromptConfigCallsBeforeFailure,
failNextUpsertChatIncludeDefaultSystemPrompt: s.failNextUpsertChatIncludeDefaultSystemPrompt,
failNextGetChatOrganizationSystemPrompt: s.failNextGetChatOrganizationSystemPrompt,
})
}, txOpts)
}
func (s *failNextChatSystemPromptStore) GetChatOrganizationSystemPrompt(ctx context.Context, organizationID uuid.UUID) (database.ChatOrganizationSystemPrompt, error) {
if s.failNextGetChatOrganizationSystemPrompt.CompareAndSwap(true, false) {
return database.ChatOrganizationSystemPrompt{}, stderrors.New("forced organization system prompt read failure")
}
return s.Store.GetChatOrganizationSystemPrompt(ctx, organizationID)
}
func (s *failNextChatSystemPromptStore) GetChatIncludeDefaultSystemPrompt(ctx context.Context) (bool, error) {
if s.failNextGetChatIncludeDefaultSystemPrompt.CompareAndSwap(true, false) {
return false, stderrors.New("forced include-default read failure")
}
return s.Store.GetChatIncludeDefaultSystemPrompt(ctx)
}
func (s *failNextChatSystemPromptStore) UpsertChatIncludeDefaultSystemPrompt(ctx context.Context, includeDefault bool) error {
if s.failNextUpsertChatIncludeDefaultSystemPrompt.CompareAndSwap(true, false) {
return stderrors.New("forced include-default upsert failure")
}
return s.Store.UpsertChatIncludeDefaultSystemPrompt(ctx, includeDefault)
}
func (s *failNextChatSystemPromptStore) GetChatSystemPromptConfig(ctx context.Context) (database.GetChatSystemPromptConfigRow, error) {
if s.failNextGetChatSystemPromptConfig.CompareAndSwap(true, false) {
return database.GetChatSystemPromptConfigRow{}, stderrors.New("forced chat system prompt configuration read failure")
}
// Armed failures fire on every read until the armed count is spent.
// Best-effort audit captures swallow these errors without retrying,
// which is why a one-shot flag is not enough: the failure would stay
// latent and fire on a later, unrelated read.
if s.armedGetChatSystemPromptConfigFailures != nil && s.armedGetChatSystemPromptConfigFailures.Load() > 0 {
// When a skip count is set, the first N reads succeed so failures
// can be aimed at a specific read, e.g. the New re-read after the
// Old capture.
if s.getChatSystemPromptConfigCallsBeforeFailure != nil && s.getChatSystemPromptConfigCallsBeforeFailure.Load() > 0 {
s.getChatSystemPromptConfigCallsBeforeFailure.Add(-1)
return s.Store.GetChatSystemPromptConfig(ctx)
}
s.armedGetChatSystemPromptConfigFailures.Add(-1)
return database.GetChatSystemPromptConfigRow{}, stderrors.New("forced chat system prompt configuration read failure")
}
return s.Store.GetChatSystemPromptConfig(ctx)
}
// failNextUpsertChatSystemPromptStore lets a test force the system-prompt
// upsert to fail once, sharing its failure state across InTx wrappers.
type failNextUpsertChatSystemPromptStore struct {
database.Store
failNextUpsertChatSystemPrompt *atomic.Bool
}
func newFailNextUpsertChatSystemPromptStore(store database.Store) *failNextUpsertChatSystemPromptStore {
return &failNextUpsertChatSystemPromptStore{
Store: store,
failNextUpsertChatSystemPrompt: &atomic.Bool{},
}
}
func (s *failNextUpsertChatSystemPromptStore) InTx(function func(database.Store) error, txOpts *database.TxOptions) error {
return s.Store.InTx(func(tx database.Store) error {
return function(&failNextUpsertChatSystemPromptStore{
Store: tx,
failNextUpsertChatSystemPrompt: s.failNextUpsertChatSystemPrompt,
})
}, txOpts)
}
func (s *failNextUpsertChatSystemPromptStore) UpsertChatSystemPrompt(ctx context.Context, prompt string) error {
if s.failNextUpsertChatSystemPrompt.CompareAndSwap(true, false) {
return stderrors.New("forced system prompt upsert failure")
}
return s.Store.UpsertChatSystemPrompt(ctx, prompt)
}
// failNextAcquireLockStore lets a test force the next advisory lock
// acquisition for one lock ID to fail with a deadline error, simulating a
// lock wait that timed out. The failure state is shared across InTx
// wrappers.
type failNextAcquireLockStore struct {
database.Store
lockID int64
failNextAcquireLock *atomic.Bool
}
func newFailNextAcquireLockStore(store database.Store, lockID int64) *failNextAcquireLockStore {
return &failNextAcquireLockStore{
Store: store,
lockID: lockID,
failNextAcquireLock: &atomic.Bool{},
}
}
func (s *failNextAcquireLockStore) InTx(function func(database.Store) error, txOpts *database.TxOptions) error {
return s.Store.InTx(func(tx database.Store) error {
return function(&failNextAcquireLockStore{
Store: tx,
lockID: s.lockID,
failNextAcquireLock: s.failNextAcquireLock,
})
}, txOpts)
}
func (s *failNextAcquireLockStore) AcquireLock(ctx context.Context, id int64) error {
if id == s.lockID && s.failNextAcquireLock.CompareAndSwap(true, false) {
return context.DeadlineExceeded
}
return s.Store.AcquireLock(ctx, id)
}
type failNextTxStore struct {
database.Store
txID string
failNextTransaction *atomic.Bool
}
func newFailNextTxStore(store database.Store, txID string) *failNextTxStore {
return &failNextTxStore{
Store: store,
txID: txID,
failNextTransaction: &atomic.Bool{},
}
}
func (s *failNextTxStore) InTx(function func(database.Store) error, txOpts *database.TxOptions) error {
if txOpts != nil && txOpts.TxIdentifier == s.txID && s.failNextTransaction.CompareAndSwap(true, false) {
return stderrors.New("forced transaction failure for " + s.txID)
}
return s.Store.InTx(function, txOpts)
}
// failNextGetChatPlanModeInstructionsStore lets a test force the plan-mode
// instructions baseline read to fail once. Failure state is shared across InTx
// wrappers.
type failNextGetChatPlanModeInstructionsStore struct {
database.Store
failNextGetChatPlanModeInstructions *atomic.Bool
}
func newFailNextGetChatPlanModeInstructionsStore(store database.Store) *failNextGetChatPlanModeInstructionsStore {
return &failNextGetChatPlanModeInstructionsStore{
Store: store,
failNextGetChatPlanModeInstructions: &atomic.Bool{},
}
}
func (s *failNextGetChatPlanModeInstructionsStore) InTx(function func(database.Store) error, txOpts *database.TxOptions) error {
return s.Store.InTx(func(tx database.Store) error {
return function(&failNextGetChatPlanModeInstructionsStore{
Store: tx,
failNextGetChatPlanModeInstructions: s.failNextGetChatPlanModeInstructions,
})
}, txOpts)
}
func (s *failNextGetChatPlanModeInstructionsStore) GetChatPlanModeInstructions(ctx context.Context) (string, error) {
if s.failNextGetChatPlanModeInstructions.CompareAndSwap(true, false) {
return "", stderrors.New("forced plan mode instructions read failure")
}
return s.Store.GetChatPlanModeInstructions(ctx)
}
// failNextUpsertChatPlanModeInstructionsStore lets a test force the plan-mode
// instructions upsert to fail once, sharing its failure state across InTx
// wrappers.
type failNextUpsertChatPlanModeInstructionsStore struct {
database.Store
failNextUpsertChatPlanModeInstructions *atomic.Bool
}
func newFailNextUpsertChatPlanModeInstructionsStore(store database.Store) *failNextUpsertChatPlanModeInstructionsStore {
return &failNextUpsertChatPlanModeInstructionsStore{
Store: store,
failNextUpsertChatPlanModeInstructions: &atomic.Bool{},
}
}
func (s *failNextUpsertChatPlanModeInstructionsStore) InTx(function func(database.Store) error, txOpts *database.TxOptions) error {
return s.Store.InTx(func(tx database.Store) error {
return function(&failNextUpsertChatPlanModeInstructionsStore{
Store: tx,
failNextUpsertChatPlanModeInstructions: s.failNextUpsertChatPlanModeInstructions,
})
}, txOpts)
}
func (s *failNextUpsertChatPlanModeInstructionsStore) UpsertChatPlanModeInstructions(ctx context.Context, instructions string) error {
if s.failNextUpsertChatPlanModeInstructions.CompareAndSwap(true, false) {
return stderrors.New("forced plan mode instructions upsert failure")
}
return s.Store.UpsertChatPlanModeInstructions(ctx, instructions)
}
type chatModelConfigLockedReadMutation struct {
id uuid.UUID
model string
}
// chatModelConfigHookStore forces a specific in-transaction chat model config
// operation to behave abnormally. Each hook targets one ID and consumes
// itself on first match. The single-consume gate uses atomic.Pointer so a
// concurrent InTx wrapper cannot race with the arming goroutine.
type chatModelConfigHookStore struct {
database.Store
inTx bool
failNextUpdate *atomic.Pointer[uuid.UUID]
failNextDelete *atomic.Pointer[uuid.UUID]
failProviderReferenceLock *atomic.Pointer[uuid.UUID]
vanishAtLockedRead *atomic.Pointer[uuid.UUID]
mutateAtLockedRead *atomic.Pointer[chatModelConfigLockedReadMutation]
}
func newChatModelConfigHookStore(store database.Store) *chatModelConfigHookStore {
return &chatModelConfigHookStore{
Store: store,
failNextUpdate: &atomic.Pointer[uuid.UUID]{},
failNextDelete: &atomic.Pointer[uuid.UUID]{},
failProviderReferenceLock: &atomic.Pointer[uuid.UUID]{},
vanishAtLockedRead: &atomic.Pointer[uuid.UUID]{},
mutateAtLockedRead: &atomic.Pointer[chatModelConfigLockedReadMutation]{},
}
}
func newChatClientWithModelConfigHookStore(t testing.TB) (*codersdk.ExperimentalClient, *chatModelConfigHookStore) {
t.Helper()
rawDB, pubsub := dbtestutil.NewDB(t)
store := newChatModelConfigHookStore(rawDB)
client := newChatClient(t, func(opts *coderdtest.Options) {
opts.Database = store
opts.Pubsub = pubsub
})
return client, store
}
func (s *chatModelConfigHookStore) armFailNextUpdate(id uuid.UUID) {
s.failNextUpdate.Store(&id)
}
func (s *chatModelConfigHookStore) armFailNextDelete(id uuid.UUID) {
s.failNextDelete.Store(&id)
}
func (s *chatModelConfigHookStore) armFailProviderReferenceLock(id uuid.UUID) {
s.failProviderReferenceLock.Store(&id)
}
func (s *chatModelConfigHookStore) armVanishAtLockedRead(id uuid.UUID) {
s.vanishAtLockedRead.Store(&id)
}
func (s *chatModelConfigHookStore) armMutateAtLockedRead(id uuid.UUID, model string) {
s.mutateAtLockedRead.Store(&chatModelConfigLockedReadMutation{id: id, model: model})
}
func (s *chatModelConfigHookStore) InTx(function func(database.Store) error, txOpts *database.TxOptions) error {
return s.Store.InTx(func(tx database.Store) error {
return function(&chatModelConfigHookStore{
Store: tx,
inTx: true,
failNextUpdate: s.failNextUpdate,
failNextDelete: s.failNextDelete,
failProviderReferenceLock: s.failProviderReferenceLock,
vanishAtLockedRead: s.vanishAtLockedRead,
mutateAtLockedRead: s.mutateAtLockedRead,
})
}, txOpts)
}
func consumeChatModelConfigHook(hook *atomic.Pointer[uuid.UUID], id uuid.UUID) bool {
target := hook.Load()
if target == nil || *target != id {
return false
}
return hook.CompareAndSwap(target, nil)
}
func (s *chatModelConfigHookStore) GetAIProviderByIDForReferenceLock(
ctx context.Context,
id uuid.UUID,
) (database.AIProvider, error) {
if consumeChatModelConfigHook(s.failProviderReferenceLock, id) {
return database.AIProvider{}, stderrors.New("forced provider reference lock failure")
}
return s.Store.GetAIProviderByIDForReferenceLock(ctx, id)
}
func (s *chatModelConfigHookStore) UpdateChatModelConfig(
ctx context.Context,
arg database.UpdateChatModelConfigParams,
) (database.ChatModelConfig, error) {
if consumeChatModelConfigHook(s.failNextUpdate, arg.ID) {
return database.ChatModelConfig{}, sql.ErrNoRows
}
return s.Store.UpdateChatModelConfig(ctx, arg)
}
func (s *chatModelConfigHookStore) DeleteChatModelConfigByID(
ctx context.Context,
id uuid.UUID,
) (uuid.UUID, error) {
if consumeChatModelConfigHook(s.failNextDelete, id) {
return uuid.Nil, sql.ErrNoRows
}
return s.Store.DeleteChatModelConfigByID(ctx, id)
}
func (s *chatModelConfigHookStore) GetChatModelConfigByID(
ctx context.Context,
id uuid.UUID,
) (database.ChatModelConfig, error) {
if s.inTx && consumeChatModelConfigHook(s.vanishAtLockedRead, id) {
return database.ChatModelConfig{}, sql.ErrNoRows
}
if s.inTx {
mutation := s.mutateAtLockedRead.Load()
if mutation != nil && mutation.id == id && s.mutateAtLockedRead.CompareAndSwap(mutation, nil) {
row, err := s.Store.GetChatModelConfigByID(ctx, id)
if err != nil {
return row, err
}
row.Model = mutation.model
return row, nil
}
}
return s.Store.GetChatModelConfigByID(ctx, id)
}
type failNextGetChatSiteConfigValueStore struct {
database.Store
failNextGetChatSiteConfigValue *atomic.Bool
}
type failNextUpsertChatRetentionDaysStore struct {
database.Store
failNextUpsert *atomic.Bool
}
func newFailNextUpsertChatRetentionDaysStore(store database.Store) *failNextUpsertChatRetentionDaysStore {
return &failNextUpsertChatRetentionDaysStore{
Store: store,
failNextUpsert: &atomic.Bool{},
}
}
func (s *failNextUpsertChatRetentionDaysStore) InTx(function func(database.Store) error, txOpts *database.TxOptions) error {
return s.Store.InTx(func(tx database.Store) error {
return function(&failNextUpsertChatRetentionDaysStore{
Store: tx,
failNextUpsert: s.failNextUpsert,
})
}, txOpts)
}
func (s *failNextUpsertChatRetentionDaysStore) UpsertChatRetentionDays(ctx context.Context, retentionDays int32) error {
if s.failNextUpsert.CompareAndSwap(true, false) {
return stderrors.New("forced chat retention days upsert failure")
}
return s.Store.UpsertChatRetentionDays(ctx, retentionDays)
}
func newFailNextGetChatSiteConfigValueStore(store database.Store) *failNextGetChatSiteConfigValueStore {
return &failNextGetChatSiteConfigValueStore{
Store: store,
failNextGetChatSiteConfigValue: &atomic.Bool{},
}
}
func (s *failNextGetChatSiteConfigValueStore) InTx(function func(database.Store) error, txOpts *database.TxOptions) error {
return s.Store.InTx(func(tx database.Store) error {
return function(&failNextGetChatSiteConfigValueStore{
Store: tx,
failNextGetChatSiteConfigValue: s.failNextGetChatSiteConfigValue,
})
}, txOpts)
}
func (s *failNextGetChatSiteConfigValueStore) GetChatSiteConfigValue(
ctx context.Context,
configKey string,
) (database.GetChatSiteConfigValueRow, error) {
if s.failNextGetChatSiteConfigValue.CompareAndSwap(true, false) {
return database.GetChatSiteConfigValueRow{}, stderrors.New("forced chat site configuration read failure")
}
return s.Store.GetChatSiteConfigValue(ctx, configKey)
}
func insertAssistantMessage(
t *testing.T,
db database.Store,
chatID uuid.UUID,
modelConfigID uuid.UUID,
) {
t.Helper()
assistantContent, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("assistant"),
})
require.NoError(t, err)
_ = dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chatID,
ModelConfigID: uuid.NullUUID{UUID: modelConfigID, Valid: true},
Role: database.ChatMessageRoleAssistant,
Content: assistantContent,
})
}
func TestPostChats(t *testing.T) {
t.Parallel()
t.Run("SuccessNonDefaultOrgUsesOrgDefault", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
aiProvider := createAIProviderForTest(t, client, "openai-compat", "test-api-key")
org := dbgen.Organization(t, db, database.Organization{IsDefault: false})
// The org's Everyone group shares the org ID (migration 000058).
dbgen.Group(t, db, database.Group{
ID: org.ID,
Name: database.EveryoneGroup,
OrganizationID: org.ID,
})
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, org.ID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
contextLimit := int64(4096)
modelConfig, err := client.CreateChatModel(ctx, org.ID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
})
require.NoError(t, err)
require.True(t, modelConfig.IsDefault, "first config in the org must self-elect as default")
chat, err := memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: org.ID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello from a non-default org",
}},
})
require.NoError(t, err)
require.Equal(t, modelConfig.ID, chat.LastModelConfigID)
})
t.Run("Rejects", func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
defaultConfig := createChatModel(t, client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
newOrgMember := func(t *testing.T) (uuid.UUID, *codersdk.ExperimentalClient) {
t.Helper()
org := dbgen.Organization(t, db, database.Organization{})
orgMemberRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, org.ID)
return org.ID, codersdk.NewExperimentalClient(orgMemberRaw)
}
crossOrgMCPServerID, thirdOrgMCPServerID := uuid.New(), uuid.New()
// Parallel cases share a deployment, so prepare must not mutate
// shared fixtures.
tests := []struct {
name string
prepare func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient
wantStatus int
wantMessage string
wantDetail string
}{
{
name: "NonDefaultOrgDoesNotUseDeploymentDefault",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
orgID, orgMember := newOrgMember(t)
req.OrganizationID = orgID
return orgMember
},
wantStatus: http.StatusBadRequest,
wantMessage: "No chat model is available in this organization.",
wantDetail: "Ask an organization administrator to configure and enable a chat model.",
},
{
name: "DisabledLocalDefaultDoesNotUseDefaultOrgDefault",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
orgID, orgMember := newOrgMember(t)
dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: defaultConfig.AIProviderID, Valid: true},
Model: "disabled-local-default-" + uuid.NewString(),
OrganizationID: orgID,
IsDefault: true,
}, func(params *database.InsertChatModelConfigParams) {
params.Enabled = false
})
req.OrganizationID = orgID
return orgMember
},
wantStatus: http.StatusBadRequest,
wantMessage: "No chat model is available in this organization.",
wantDetail: "Ask an organization administrator to configure and enable a chat model.",
},
{
name: "DefaultOrgExplicitModelRejectedForNonDefaultOrg",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
orgID, orgMember := newOrgMember(t)
req.OrganizationID = orgID
req.ModelConfigID = ptr.Ref(defaultConfig.ID)
return orgMember
},
wantStatus: http.StatusBadRequest,
wantMessage: "Invalid model_config_id: model config not found or disabled.",
},
{
name: "ThirdOrgExplicitModelRejected",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
orgID, orgMember := newOrgMember(t)
thirdOrg := dbgen.Organization(t, db, database.Organization{})
thirdConfig := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: defaultConfig.AIProviderID, Valid: true},
Model: "third-org-" + uuid.NewString(),
Enabled: true,
IsDefault: true,
OrganizationID: thirdOrg.ID,
})
req.OrganizationID = orgID
req.ModelConfigID = ptr.Ref(thirdConfig.ID)
return orgMember
},
wantStatus: http.StatusBadRequest,
wantMessage: "Invalid model_config_id: model config not found or disabled.",
},
{
name: "MCPServerIDsCrossOrgRejected",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
dbgen.MCPServerConfig(t, db, database.MCPServerConfig{
ID: crossOrgMCPServerID,
OrganizationID: firstUser.OrganizationID,
Enabled: true,
})
orgID, orgMember := newOrgMember(t)
dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: defaultConfig.AIProviderID, Valid: true},
OrganizationID: orgID,
IsDefault: true,
})
req.OrganizationID = orgID
req.MCPServerIDs = []uuid.UUID{crossOrgMCPServerID}
return orgMember
},
wantStatus: http.StatusBadRequest,
wantMessage: "One or more MCP server IDs are invalid or disabled.",
wantDetail: "Invalid IDs: " + crossOrgMCPServerID.String(),
},
{
name: "MCPServerIDsThirdOrgRejected",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
thirdOrg := dbgen.Organization(t, db, database.Organization{})
dbgen.MCPServerConfig(t, db, database.MCPServerConfig{
ID: thirdOrgMCPServerID,
OrganizationID: thirdOrg.ID,
Enabled: true,
})
orgID, orgMember := newOrgMember(t)
dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: defaultConfig.AIProviderID, Valid: true},
OrganizationID: orgID,
IsDefault: true,
})
req.OrganizationID = orgID
req.MCPServerIDs = []uuid.UUID{thirdOrgMCPServerID}
return orgMember
},
wantStatus: http.StatusBadRequest,
wantMessage: "One or more MCP server IDs are invalid or disabled.",
wantDetail: "Invalid IDs: " + thirdOrgMCPServerID.String(),
},
{
name: "RejectsInvalidReasoningEffort",
prepare: func(_ *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
req.ReasoningEffort = ptr.Ref(" HIGH ")
return client
},
wantStatus: http.StatusBadRequest,
wantMessage: "Invalid reasoning_effort value.",
wantDetail: `Invalid value " HIGH ", must be one of none, minimal, low, medium, high, xhigh, max`,
},
{
name: "DisabledModelConfigRejected",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
disabledConfig := createDisabledChatModel(
t,
client,
coderdtest.TestChatProviderOpenAICompat,
"gpt-4o-create-disabled-"+uuid.NewString(),
)
req.ModelConfigID = ptr.Ref(disabledConfig.ID)
return client
},
wantStatus: http.StatusBadRequest,
wantMessage: "Invalid model_config_id: model config not found or disabled.",
},
{
name: "ProviderDisabledModelConfigRejected",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
providerDisabledConfig := createProviderDisabledChatModel(
t,
client,
"openai",
"gpt-4o-create-provider-disabled-"+uuid.NewString(),
)
req.ModelConfigID = ptr.Ref(providerDisabledConfig.ID)
return client
},
wantStatus: http.StatusBadRequest,
wantMessage: "Invalid model_config_id: provider is not enabled for this model.",
},
{
name: "DeniedSameOrganizationExplicitModelIsRejected",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
provider := createAIProviderForTest(t, client, "openai-compat", "test-api-key")
privateConfig := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: provider.ID, Valid: true},
Model: "private-explicit-" + uuid.NewString(),
Enabled: true,
OrganizationID: firstUser.OrganizationID,
GroupACL: database.ChatACL{},
})
req.ModelConfigID = ptr.Ref(privateConfig.ID)
return memberClient
},
wantStatus: http.StatusBadRequest,
wantMessage: "Invalid model_config_id: model config not found or disabled.",
},
{
name: "WorkspaceNotAccessible",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
workspaceBuild := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
}).WithAgent().Do()
req.WorkspaceID = &workspaceBuild.Workspace.ID
return memberClient
},
wantStatus: http.StatusBadRequest,
wantMessage: "Workspace not found or you do not have access to this resource",
},
{
name: "WorkspaceAccessibleButNoSSH",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
orgAdminClientRaw, _ := coderdtest.CreateAnotherUser(
t,
client.Client,
firstUser.OrganizationID,
rbac.ScopedRoleOrgAdmin(firstUser.OrganizationID),
)
workspaceBuild := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
}).WithAgent().Do()
req.WorkspaceID = &workspaceBuild.Workspace.ID
return codersdk.NewExperimentalClient(orgAdminClientRaw)
},
wantStatus: http.StatusBadRequest,
wantMessage: "Workspace not found or you do not have access to this resource",
},
{
name: "WorkspaceNotFound",
prepare: func(_ *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
req.WorkspaceID = ptr.Ref(uuid.New())
return client
},
wantStatus: http.StatusBadRequest,
wantMessage: "Workspace not found or you do not have access to this resource",
},
{
name: "EmptyText",
// No model exists in the new org, so this also checks that
// input is rejected before model resolution.
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
orgID, orgMember := newOrgMember(t)
req.OrganizationID = orgID
req.Content[0].Text = " "
return orgMember
},
wantStatus: http.StatusBadRequest,
wantMessage: "Invalid input part.",
wantDetail: "content[0].text cannot be empty.",
},
{
name: "UnsupportedPartType",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
orgID, orgMember := newOrgMember(t)
req.OrganizationID = orgID
req.Content[0].Type = codersdk.ChatInputPartType("image")
return orgMember
},
wantStatus: http.StatusBadRequest,
wantMessage: "Invalid input part.",
wantDetail: `content[0].type "image" is not supported.`,
},
{
name: "NilOrganizationID",
prepare: func(_ *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
req.OrganizationID = uuid.Nil
return memberClient
},
wantStatus: http.StatusBadRequest,
wantMessage: "organization_id is required.",
},
{
name: "NonMemberOrganization",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
req.OrganizationID = dbgen.Organization(t, db, database.Organization{}).ID
return memberClient
},
wantStatus: http.StatusForbidden,
wantMessage: "You are not a member of the specified organization.",
},
{
name: "CrossOrgWorkspaceMismatch",
prepare: func(t *testing.T, req *codersdk.CreateChatRequest) *codersdk.ExperimentalClient {
workspaceBuild := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
}).WithAgent().Do()
// The admin joins the second organization so the request
// passes the membership check and fails on the workspace.
secondOrg := dbgen.Organization(t, db, database.Organization{})
dbgen.OrganizationMember(t, db, database.OrganizationMember{
OrganizationID: secondOrg.ID,
UserID: firstUser.UserID,
})
req.OrganizationID = secondOrg.ID
req.WorkspaceID = &workspaceBuild.Workspace.ID
return client
},
wantStatus: http.StatusBadRequest,
wantMessage: "Workspace does not belong to the specified organization.",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
req := codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
}},
}
chatClient := tt.prepare(t, &req)
_, err := chatClient.CreateChat(ctx, req)
sdkErr := requireSDKError(t, err, tt.wantStatus)
require.Equal(t, tt.wantMessage, sdkErr.Message)
require.Equal(t, tt.wantDetail, sdkErr.Detail)
})
}
})
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
client := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat, err := memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
PlanMode: codersdk.ChatPlanModePlan,
OrganizationID: firstUser.OrganizationID, Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "hello from chats route tests",
},
},
})
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, chat.ID)
require.Equal(t, member.ID, chat.OwnerID)
require.Equal(t, modelConfig.ID, chat.LastModelConfigID)
require.Equal(t, "hello from chats route tests", chat.Title)
require.NotZero(t, chat.CreatedAt)
require.NotZero(t, chat.UpdatedAt)
require.Nil(t, chat.WorkspaceID)
require.NotNil(t, chat.RootChatID)
require.Equal(t, chat.ID, *chat.RootChatID)
chatResult, err := memberClient.GetChat(ctx, chat.ID)
require.NoError(t, err)
messagesResult, err := memberClient.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
require.Equal(t, chat.ID, chatResult.ID)
require.Equal(t, codersdk.ChatPlanModePlan, chatResult.PlanMode)
foundUserMessage := false
for _, message := range messagesResult.Messages {
if message.Role != codersdk.ChatMessageRoleUser {
continue
}
for _, part := range message.Content {
if part.Type == codersdk.ChatMessagePartTypeText &&
part.Text == "hello from chats route tests" {
foundUserMessage = true
break
}
}
}
require.True(t, foundUserMessage)
require.True(t, mAudit.Contains(t, database.AuditLog{
Action: database.AuditActionCreate,
ResourceType: database.ResourceTypeChat,
ResourceID: chat.ID,
ResourceTarget: chat.ID.String()[:8],
UserID: member.ID,
}))
})
t.Run("MCPServerIDsDuplicatesNormalized", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
coderdtest.CreateFirstUser(t, client.Client)
deploymentDefault := createChatModel(t, client)
secondOrg := dbgen.Organization(t, db, database.Organization{})
_ = dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: deploymentDefault.AIProviderID, Valid: true},
OrganizationID: secondOrg.ID,
IsDefault: true,
})
orgConfig := dbgen.MCPServerConfig(t, db, database.MCPServerConfig{
OrganizationID: secondOrg.ID,
Enabled: true,
})
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, secondOrg.ID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat, err := memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: secondOrg.ID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "chat with a duplicated MCP server ID",
},
},
MCPServerIDs: []uuid.UUID{orgConfig.ID, orgConfig.ID},
})
require.NoError(t, err)
require.Equal(t, []uuid.UUID{orgConfig.ID}, chat.MCPServerIDs)
_, err = memberClient.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "update to a duplicated MCP server ID",
},
},
MCPServerIDs: &[]uuid.UUID{orgConfig.ID, orgConfig.ID},
})
require.NoError(t, err)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, []uuid.UUID{orgConfig.ID}, storedChat.MCPServerIDs)
})
t.Run("MCPServerIDsDisabledConfigRejected", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
enabledCfg := dbgen.MCPServerConfig(t, db, database.MCPServerConfig{
OrganizationID: firstUser.OrganizationID,
Enabled: true,
})
disabledCfg, err := client.UpdateMCPServerConfig(ctx, enabledCfg.OrganizationID, enabledCfg.ID, codersdk.UpdateMCPServerConfigRequest{
Enabled: ptr.Ref(false),
})
require.NoError(t, err)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
_, err = memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "chat with a disabled MCP server",
},
},
MCPServerIDs: []uuid.UUID{disabledCfg.ID},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "One or more MCP server IDs are invalid or disabled.", sdkErr.Message)
require.Equal(t, "Invalid IDs: "+disabledCfg.ID.String(), sdkErr.Detail)
chat, err := memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "chat without MCP servers",
},
},
})
require.NoError(t, err)
_, err = memberClient.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "selecting the disabled config",
},
},
MCPServerIDs: &[]uuid.UUID{disabledCfg.ID},
})
sdkErr = requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "One or more MCP server IDs are invalid or disabled.", sdkErr.Message)
require.Equal(t, "Invalid IDs: "+disabledCfg.ID.String(), sdkErr.Detail)
})
t.Run("MCPServerIDsPersistedDisabledStillSendable", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
cfg := dbgen.MCPServerConfig(t, db, database.MCPServerConfig{
OrganizationID: firstUser.OrganizationID,
Enabled: true,
})
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat, err := memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "chat with a server that is disabled later",
},
},
MCPServerIDs: []uuid.UUID{cfg.ID},
})
require.NoError(t, err)
_, err = client.UpdateMCPServerConfig(ctx, cfg.OrganizationID, cfg.ID, codersdk.UpdateMCPServerConfigRequest{
Enabled: ptr.Ref(false),
})
require.NoError(t, err)
// The frontend resubmits the persisted selection on every
// send, so a server disabled after selection must not block
// the send.
_, err = memberClient.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "still sendable after the server was disabled",
},
},
MCPServerIDs: &[]uuid.UUID{cfg.ID},
})
require.NoError(t, err)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, []uuid.UUID{cfg.ID}, storedChat.MCPServerIDs)
secondCfg := dbgen.MCPServerConfig(t, db, database.MCPServerConfig{
OrganizationID: firstUser.OrganizationID,
Enabled: true,
})
_, err = client.UpdateMCPServerConfig(ctx, secondCfg.OrganizationID, secondCfg.ID, codersdk.UpdateMCPServerConfigRequest{
Enabled: ptr.Ref(false),
})
require.NoError(t, err)
_, err = memberClient.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "adding another disabled server is rejected",
},
},
MCPServerIDs: &[]uuid.UUID{cfg.ID, secondCfg.ID},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "One or more MCP server IDs are invalid or disabled.", sdkErr.Message)
require.Equal(t, "Invalid IDs: "+secondCfg.ID.String(), sdkErr.Detail)
})
t.Run("MemberCanCreateChat", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat, err := memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "hello from an organization member",
},
},
})
require.NoError(t, err)
require.Equal(t, member.ID, chat.OwnerID)
})
t.Run("AgentsAccessDefaultRole", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
client := newChatClient(t, func(opts *coderdtest.Options) {
opts.Database = rawDB
opts.Pubsub = pubsub
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
createChat := func() error {
_, err := memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "hello"},
},
})
return err
}
setDefaults := func(roles []string) {
t.Helper()
org, err := rawDB.GetOrganizationByID(ctx, firstUser.OrganizationID)
require.NoError(t, err)
_, err = rawDB.UpdateOrganization(ctx, database.UpdateOrganizationParams{
ID: org.ID,
UpdatedAt: dbtime.Now(),
Name: org.Name,
DisplayName: org.DisplayName,
Description: org.Description,
Icon: org.Icon,
DefaultOrgMemberRoles: roles,
})
require.NoError(t, err)
}
setMemberRoles := func(roles []string) {
t.Helper()
_, err := client.UpdateOrganizationMemberRoles(ctx, firstUser.OrganizationID, member.ID.String(), codersdk.UpdateRoles{Roles: roles})
require.NoError(t, err)
}
setDefaults([]string{codersdk.RoleOrganizationWorkspaceAccess})
requireSDKError(t, createChat(), http.StatusForbidden)
setMemberRoles([]string{codersdk.RoleAgentsAccess})
require.NoError(t, createChat())
setMemberRoles([]string{})
requireSDKError(t, createChat(), http.StatusForbidden)
setDefaults(rbac.DefaultOrgMemberRoles())
require.NoError(t, createChat())
})
t.Run("WithReasoningEffort", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "think hard from the start",
},
},
ReasoningEffort: ptr.Ref("high"),
})
require.NoError(t, err)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.True(t, storedChat.LastReasoningEffort.Valid)
require.Equal(t, database.ChatReasoningEffortHigh, storedChat.LastReasoningEffort.ChatReasoningEffort)
messages, err := db.GetChatMessagesByChatID(dbauthz.AsSystemRestricted(ctx), database.GetChatMessagesByChatIDParams{
ChatID: chat.ID,
AfterID: 0,
})
require.NoError(t, err)
userMsg := findUserMessage(t, messages)
require.True(t, userMsg.ReasoningEffort.Valid)
require.Equal(t, database.ChatReasoningEffortHigh, userMsg.ReasoningEffort.ChatReasoningEffort)
})
t.Run("HidesSystemPromptMessages", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "verify hidden system prompt",
},
},
})
require.NoError(t, err)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
for _, message := range messagesResult.Messages {
require.NotEqual(t, codersdk.ChatMessageRoleSystem, message.Role)
}
})
t.Run("ProviderDisabledDefaultModelRejected", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
defaultConfig := createChatModel(t, client)
_, err := client.UpdateAIProvider(ctx, defaultConfig.AIProviderID.String(), codersdk.UpdateAIProviderRequest{
Enabled: ptr.Ref(false),
})
require.NoError(t, err)
// Omitting model_config_id resolves the default model, whose
// provider is now disabled.
_, err = client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
}},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "No chat model is available in this organization.", sdkErr.Message)
require.Equal(t, "Ask an organization administrator to configure and enable a chat model.", sdkErr.Detail)
})
t.Run("DeniedSameOrganizationDefaultIsRejected", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
provider := createAIProviderForTest(t, client, "openai-compat", "test-api-key")
_ = dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: provider.ID, Valid: true},
Model: "private-default-" + uuid.NewString(),
Enabled: true,
IsDefault: true,
OrganizationID: firstUser.OrganizationID,
GroupACL: database.ChatACL{},
})
memberClientRaw, _ := coderdtest.CreateAnotherUser(
t,
client.Client,
firstUser.OrganizationID,
)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
_, err := memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "do not select the private default",
}},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "No chat model is available in this organization.", sdkErr.Message)
})
t.Run("WithPerChatSystemPrompt", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "hello with system prompt",
},
},
SystemPrompt: "You are a Go expert.",
})
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, chat.ID)
// Use the DB directly to see system messages, which are
// hidden from the public API.
dbMessages, err := db.GetChatMessagesForPromptByChatID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
// Expect: deployment system prompt, per-chat system prompt,
// workspace awareness, user message.
var systemMessages []database.ChatMessage
for _, msg := range dbMessages {
if msg.Role == database.ChatMessageRoleSystem {
systemMessages = append(systemMessages, msg)
}
}
require.GreaterOrEqual(t, len(systemMessages), 2,
"expected at least deployment + per-chat system messages")
// The per-chat system prompt should be the second system
// message and contain the user-specified text.
foundPerChat := false
for _, msg := range systemMessages {
if msg.Content.Valid {
raw := string(msg.Content.RawMessage)
if strings.Contains(raw, "You are a Go expert.") {
foundPerChat = true
break
}
}
}
require.True(t, foundPerChat,
"per-chat system prompt not found in system messages")
})
t.Run("PerChatSystemPromptEmpty", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "hello without system prompt",
},
},
SystemPrompt: "",
})
require.NoError(t, err)
dbMessages, err := db.GetChatMessagesForPromptByChatID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
// No per-chat system prompt should be present.
for _, msg := range dbMessages {
if msg.Role == database.ChatMessageRoleSystem && msg.Content.Valid {
raw := string(msg.Content.RawMessage)
require.NotContains(t, raw, "You are a Go expert.",
"unexpected per-chat system prompt in messages")
}
}
})
t.Run("WorkspaceSelectsFirstAgent", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
workspaceBuild := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
}).WithAgent().Do()
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
},
},
WorkspaceID: &workspaceBuild.Workspace.ID,
})
require.NoError(t, err)
require.NotNil(t, chat.WorkspaceID)
require.Equal(t, workspaceBuild.Workspace.ID, *chat.WorkspaceID)
require.Equal(t, modelConfig.ID, chat.LastModelConfigID)
})
t.Run("MissingDefaultModelConfig", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
},
},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "No chat model is available in this organization.", sdkErr.Message)
require.Equal(t, "Ask an organization administrator to configure and enable a chat model.", sdkErr.Detail)
})
t.Run("EmptyContent", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Empty content creates an idle chat; see
// TestPostChats_EmptyContent for the full behavior.
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: nil,
})
require.NoError(t, err)
require.Equal(t, codersdk.ChatStatusWaiting, chat.Status)
})
}
func TestCreateChatAsUser(t *testing.T) {
t.Parallel()
mAudit := audit.NewMock()
client, api := newChatClientWithAPI(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
createChatModel(t, client)
helloRequest := func(organizationID uuid.UUID) codersdk.CreateChatRequest {
return codersdk.CreateChatRequest{
OrganizationID: organizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello from CreateChatAsUser",
}},
}
}
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
chat, err := api.CreateChatAsUser(ctx, member.ID, helloRequest(firstUser.OrganizationID))
require.NoError(t, err)
require.Equal(t, member.ID, chat.OwnerID)
require.Equal(t, codersdk.ChatClientTypeAPI, chat.ClientType)
require.Equal(t, "hello from CreateChatAsUser", chat.Title)
require.True(t, mAudit.Contains(t, database.AuditLog{
Action: database.AuditActionCreate,
ResourceType: database.ResourceTypeChat,
ResourceID: chat.ID,
UserID: member.ID,
OrganizationID: firstUser.OrganizationID,
StatusCode: http.StatusCreated,
}))
})
t.Run("RefusedUser", func(t *testing.T) {
t.Parallel()
cases := []struct {
name string
refuse func(ctx context.Context, t *testing.T, userID uuid.UUID) uuid.UUID
wantMessage string
}{
{
name: "SuspendedUser",
refuse: func(ctx context.Context, t *testing.T, userID uuid.UUID) uuid.UUID {
_, err := client.UpdateUserStatus(ctx, userID.String(), codersdk.UserStatusSuspended)
require.NoError(t, err)
return userID
},
wantMessage: "not active",
},
{
name: "DeletedUser",
refuse: func(ctx context.Context, t *testing.T, userID uuid.UUID) uuid.UUID {
require.NoError(t, client.DeleteUser(ctx, userID))
return userID
},
wantMessage: "User is deleted.",
},
{
name: "MissingUser",
refuse: func(context.Context, *testing.T, uuid.UUID) uuid.UUID {
return uuid.New()
},
wantMessage: "User does not exist.",
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
userID := tc.refuse(ctx, t, member.ID)
_, err := api.CreateChatAsUser(ctx, userID, helloRequest(firstUser.OrganizationID))
responder, ok := httperror.IsResponder(err)
require.True(t, ok, "want a responder error, got %v", err)
status, resp := responder.Response()
require.Equal(t, http.StatusForbidden, status)
require.Contains(t, resp.Message, tc.wantMessage)
chats, err := api.Database.GetChats(dbauthz.AsSystemRestricted(ctx), database.GetChatsParams{
OwnedOnly: true,
ViewerID: userID,
})
require.NoError(t, err)
require.Empty(t, chats)
for _, log := range mAudit.AuditLogs() {
require.False(t, log.ResourceType == database.ResourceTypeChat && log.UserID == userID, "refused user got a chat audit entry")
}
})
}
})
t.Run("AccountStatus", func(t *testing.T) {
t.Parallel()
activationAudits := func(userID uuid.UUID) int {
count := 0
for _, log := range mAudit.AuditLogs() {
if log.ResourceType == database.ResourceTypeUser && log.ResourceID == userID && log.Action == database.AuditActionWrite {
count++
}
}
return count
}
cases := []struct {
name string
status database.UserStatus
lastSeenAgo time.Duration
wantSeen bool
}{
{name: "DormantIsActivated", status: database.UserStatusDormant, lastSeenAgo: 100 * 24 * time.Hour, wantSeen: true},
{name: "SeenRecentlyKeepsLastSeen", status: database.UserStatusActive, lastSeenAgo: 30 * time.Minute},
{name: "SeenOverAnHourAgoUpdatesLastSeen", status: database.UserStatusActive, lastSeenAgo: 2 * time.Hour, wantSeen: true},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
systemCtx := dbauthz.AsSystemRestricted(ctx)
now := dbtime.Now()
lastSeen := now.Add(-tc.lastSeenAgo)
_, err := api.Database.UpdateUserLastSeenAt(systemCtx, database.UpdateUserLastSeenAtParams{
ID: member.ID,
LastSeenAt: lastSeen,
UpdatedAt: now,
})
require.NoError(t, err)
_, err = api.Database.UpdateUserStatus(systemCtx, database.UpdateUserStatusParams{
ID: member.ID,
Status: tc.status,
UpdatedAt: now,
})
require.NoError(t, err)
auditsBefore := activationAudits(member.ID)
_, err = api.CreateChatAsUser(ctx, member.ID, helloRequest(firstUser.OrganizationID))
require.NoError(t, err)
user, err := api.Database.GetUserByID(systemCtx, member.ID)
require.NoError(t, err)
require.Equal(t, database.UserStatusActive, user.Status)
if tc.wantSeen {
require.True(t, user.LastSeenAt.After(lastSeen), "last_seen_at stayed at %s", user.LastSeenAt)
} else {
require.True(t, lastSeen.Equal(user.LastSeenAt), "last_seen_at changed from %s to %s", lastSeen, user.LastSeenAt)
}
wantAudits := auditsBefore
if tc.status == database.UserStatusDormant {
wantAudits++
}
require.Equal(t, wantAudits, activationAudits(member.ID))
})
}
})
t.Run("HookDenied", func(t *testing.T) {
t.Parallel()
const hookSecret = "test-hook-secret-32-bytes-minimum!!"
consumer := newHookConsumer(t, hookSecret, agenthooks.Hooks{
UserPromptSubmit: func(context.Context, agenthooks.Meta, agenthooks.UserPromptSubmitData) (agenthooks.Response, error) {
return agenthooks.Response{
Permission: &agenthooks.Permission{Decision: agenthooks.PermissionDeny},
UserMessage: "blocked by policy",
}, nil
},
})
t.Cleanup(consumer.Close)
hookClient, hookAPI := newChatClientWithAPI(t, func(opts *coderdtest.Options) {
opts.ChatWorkerDisabled = true
require.NoError(t, opts.DeploymentValues.AI.Chat.HookURL.Set(consumer.URL))
opts.DeploymentValues.AI.Chat.HookSecret = serpent.String(hookSecret)
opts.DeploymentValues.AI.Chat.HookTimeout = serpent.Duration(testutil.WaitShort)
opts.DeploymentValues.AI.Chat.HookEnabled = serpent.Bool(true)
})
hookUser := coderdtest.CreateFirstUser(t, hookClient.Client)
createChatModel(t, hookClient)
ctx := testutil.Context(t, testutil.WaitLong)
_, err := hookAPI.CreateChatAsUser(ctx, hookUser.UserID, helloRequest(hookUser.OrganizationID))
responder, ok := httperror.IsResponder(err)
require.True(t, ok, "want a responder error, got %v", err)
status, resp := responder.Response()
require.Equal(t, http.StatusForbidden, status)
require.Equal(t, "blocked by policy", resp.Message)
denied, ok := stderrors.AsType[*chathooks.UserPromptDeniedError](err)
require.True(t, ok, "want a hook denial, got %v", err)
require.Equal(t, "blocked by policy", denied.UserMessage)
})
}
func TestActOnChatAsUser(t *testing.T) {
t.Parallel()
mAudit := audit.NewMockWithDiffFn(func(old, newVal any) audit.Map {
diff := audit.Map{}
oldChat, oldOK := old.(database.Chat)
newChat, newOK := newVal.(database.Chat)
if !oldOK || !newOK {
return diff
}
if oldChat.ID != newChat.ID {
diff["id"] = audit.OldNew{Old: oldChat.ID, New: newChat.ID}
}
if oldChat.Archived != newChat.Archived {
diff["archived"] = audit.OldNew{Old: oldChat.Archived, New: newChat.Archived}
}
return diff
})
client, api := newChatClientWithAPI(t, withChatWorkerDisabled, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
createChatModel(t, client)
newChat := func(ctx context.Context, t *testing.T) (*codersdk.ExperimentalClient, codersdk.Chat) {
t.Helper()
memberClient, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
chat, err := api.CreateChatAsUser(ctx, member.ID, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: "hello"}},
})
require.NoError(t, err)
return codersdk.NewExperimentalClient(memberClient), chat
}
acquireChat := func(ctx context.Context, t *testing.T, chatID uuid.UUID) {
t.Helper()
chatdCtx := dbauthz.AsChatd(ctx) //nolint:gocritic // Test fixture mirrors chatd background transitions.
machine := chatstate.NewChatMachine(api.Database, api.Pubsub, chatID)
_, err := machine.Update(chatdCtx, func(tx *chatstate.Tx, _ database.Store, _ *chatstate.ChatSnapshot) error {
_, err := tx.Acquire(chatstate.AcquireInput{WorkerID: uuid.New(), RunnerID: uuid.New()})
return err
})
require.NoError(t, err)
}
message := codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: "hello again"}},
}
unarchiveRequest := codersdk.UpdateChatRequest{Archived: ptr.Ref(false)}
chatWrites := func(chatID uuid.UUID) []database.AuditLog {
var logs []database.AuditLog
for _, log := range mAudit.AuditLogs() {
if log.ResourceID == chatID && log.Action == database.AuditActionWrite {
logs = append(logs, log)
}
}
return logs
}
requireSameAudit := func(t *testing.T, overHTTP, inProcess database.AuditLog) {
t.Helper()
require.Equal(t, overHTTP.ResourceType, inProcess.ResourceType)
require.Equal(t, overHTTP.ResourceTarget, inProcess.ResourceTarget)
require.Equal(t, overHTTP.UserID, inProcess.UserID)
require.Equal(t, overHTTP.OrganizationID, inProcess.OrganizationID)
require.Equal(t, overHTTP.StatusCode, inProcess.StatusCode)
}
t.Run("Send", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, chat := newChat(ctx, t)
driveChatToWaiting(ctx, t, api, chat.ID)
resp, err := api.SendChatMessageAsUser(ctx, chat.OwnerID, chat.ID, message)
require.NoError(t, err)
require.False(t, resp.Queued)
require.NotNil(t, resp.Message)
require.Equal(t, codersdk.ChatMessageRoleUser, resp.Message.Role)
})
t.Run("Interrupt", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, chat := newChat(ctx, t)
acquireChat(ctx, t, chat.ID)
interrupted, err := api.InterruptChatAsUser(ctx, chat.OwnerID, chat.ID)
require.NoError(t, err)
require.Equal(t, chat.ID, interrupted.ID)
require.Equal(t, codersdk.ChatStatusInterrupting, interrupted.Status)
})
t.Run("Unarchive", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
memberClient, chat := newChat(ctx, t)
driveChatToWaiting(ctx, t, api, chat.ID)
require.NoError(t, memberClient.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)}))
require.NoError(t, api.UpdateChatAsUser(ctx, chat.OwnerID, chat.ID, unarchiveRequest))
got, err := memberClient.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.False(t, got.Archived)
logs := chatWrites(chat.ID)
require.Len(t, logs, 2)
archive, unarchive := logs[0], logs[1]
requireSameAudit(t, archive, unarchive)
require.Equal(t, chat.OwnerID, unarchive.UserID)
require.EqualValues(t, http.StatusNoContent, unarchive.StatusCode)
var diff map[string]codersdk.AuditDiffField
require.NoError(t, json.Unmarshal(unarchive.Diff, &diff))
require.Equal(t, map[string]codersdk.AuditDiffField{"archived": {Old: true, New: false}}, diff)
})
t.Run("UpdateAuditOnFailure", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
memberClient, chat := newChat(ctx, t)
require.Error(t, memberClient.UpdateChat(ctx, chat.ID, unarchiveRequest))
require.Error(t, api.UpdateChatAsUser(ctx, chat.OwnerID, chat.ID, unarchiveRequest))
logs := chatWrites(chat.ID)
require.Len(t, logs, 2)
overHTTP, inProcess := logs[0], logs[1]
requireSameAudit(t, overHTTP, inProcess)
require.EqualValues(t, http.StatusBadRequest, inProcess.StatusCode)
require.JSONEq(t, "{}", string(overHTTP.Diff))
require.JSONEq(t, "{}", string(inProcess.Diff))
})
t.Run("Refused", func(t *testing.T) {
t.Parallel()
send := func(ctx context.Context, userID, chatID uuid.UUID) error {
_, err := api.SendChatMessageAsUser(ctx, userID, chatID, message)
return err
}
interrupt := func(ctx context.Context, userID, chatID uuid.UUID) error {
_, err := api.InterruptChatAsUser(ctx, userID, chatID)
return err
}
unarchive := func(ctx context.Context, userID, chatID uuid.UUID) error {
return api.UpdateChatAsUser(ctx, userID, chatID, unarchiveRequest)
}
otherUser := func(_ context.Context, t *testing.T, _ *codersdk.ExperimentalClient, _ codersdk.Chat) uuid.UUID {
_, other := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
return other.ID
}
cases := []struct {
name string
act func(ctx context.Context, userID, chatID uuid.UUID) error
prepare func(ctx context.Context, t *testing.T, memberClient *codersdk.ExperimentalClient, chat codersdk.Chat) uuid.UUID
wantStatus int
wantMessage string
}{
{
name: "SendOtherUsersChat",
act: send,
prepare: otherUser,
wantStatus: http.StatusNotFound,
wantMessage: "Resource not found",
},
{
name: "SendSiteOwnerNotChatOwner",
act: send,
prepare: func(context.Context, *testing.T, *codersdk.ExperimentalClient, codersdk.Chat) uuid.UUID {
return firstUser.UserID
},
wantStatus: http.StatusForbidden,
wantMessage: "Only the chat owner may send messages.",
},
{
name: "InterruptOtherUsersChat",
act: interrupt,
prepare: otherUser,
wantStatus: http.StatusNotFound,
wantMessage: "Resource not found",
},
{
name: "UnarchiveReadOnlyMember",
act: unarchive,
prepare: func(ctx context.Context, t *testing.T, memberClient *codersdk.ExperimentalClient, chat codersdk.Chat) uuid.UUID {
driveChatToWaiting(ctx, t, api, chat.ID)
require.NoError(t, memberClient.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)}))
_, reader := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
require.NoError(t, memberClient.UpdateChatACL(ctx, chat.ID, codersdk.UpdateChatACL{
UserRoles: map[string]codersdk.ChatRole{reader.ID.String(): codersdk.ChatRoleRead},
}))
return reader.ID
},
wantStatus: http.StatusNotFound,
wantMessage: "Resource not found",
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
memberClient, chat := newChat(ctx, t)
userID := tc.prepare(ctx, t, memberClient, chat)
err := tc.act(ctx, userID, chat.ID)
responder, ok := httperror.IsResponder(err)
require.True(t, ok, "want a responder error, got %v", err)
status, resp := responder.Response()
require.Equal(t, tc.wantStatus, status)
require.Contains(t, resp.Message, tc.wantMessage)
})
}
})
}
func TestPostChats_OwnerID(t *testing.T) {
t.Parallel()
helloRequest := func(ownerID, organizationID uuid.UUID) codersdk.CreateChatRequest {
return codersdk.CreateChatRequest{
OrganizationID: organizationID,
OwnerID: &ownerID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello on behalf of another user",
}},
}
}
t.Run("OwnerCreatesForMember", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat, err := client.CreateChat(ctx, helloRequest(member.ID, firstUser.OrganizationID))
require.NoError(t, err)
require.Equal(t, member.ID, chat.OwnerID)
// The member can read the chat; the prompt stays attributed to the admin.
_, err = memberClient.GetChat(ctx, chat.ID)
require.NoError(t, err)
messages, err := db.GetChatMessagesByChatID(dbauthz.AsSystemRestricted(ctx), database.GetChatMessagesByChatIDParams{
ChatID: chat.ID,
})
require.NoError(t, err)
userMsg := findUserMessage(t, messages)
require.Equal(t, uuid.NullUUID{UUID: firstUser.UserID, Valid: true}, userMsg.CreatedBy)
})
t.Run("OwnerServiceAccountCreatesForMember", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
_, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
// Service accounts are a licensed feature, so seed one directly. It
// is not an organization member: site-wide authority is sufficient.
serviceAccount := dbgen.User(t, db, database.User{
IsServiceAccount: true,
RBACRoles: []string{rbac.RoleOwner().String()},
})
_, token := dbgen.APIKey(t, db, database.APIKey{
UserID: serviceAccount.ID,
LoginType: database.LoginTypeToken,
})
serviceAccountClient := codersdk.New(
client.URL,
codersdk.WithSessionToken(token),
codersdk.WithHTTPClient(coderdtest.NewIsolatedHTTPClient(client.URL)),
)
t.Cleanup(serviceAccountClient.HTTPClient.CloseIdleConnections)
chat, err := serviceAccountClient.CreateChat(ctx, helloRequest(member.ID, firstUser.OrganizationID))
require.NoError(t, err)
require.Equal(t, member.ID, chat.OwnerID)
})
t.Run("OwnerIDNil", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
_, err := client.CreateChat(ctx, helloRequest(uuid.Nil, firstUser.OrganizationID))
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid owner_id: must be a user ID or omitted.", sdkErr.Message)
})
t.Run("OwnerIDIsCaller", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat, err := memberClient.CreateChat(ctx, helloRequest(member.ID, firstUser.OrganizationID))
require.NoError(t, err)
require.Equal(t, member.ID, chat.OwnerID)
})
t.Run("WorkspaceOwnedByMember", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
_, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
workspaceBuild := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: firstUser.OrganizationID,
OwnerID: member.ID,
}).WithAgent().Do()
req := helloRequest(member.ID, firstUser.OrganizationID)
req.WorkspaceID = &workspaceBuild.Workspace.ID
chat, err := client.CreateChat(ctx, req)
require.NoError(t, err)
require.NotNil(t, chat.WorkspaceID)
require.Equal(t, workspaceBuild.Workspace.ID, *chat.WorkspaceID)
})
t.Run("WorkspaceNotAccessibleToOwner", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
_, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
workspaceBuild := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
}).WithAgent().Do()
// The admin can reach their own workspace, but the chat connects
// as the member, who cannot.
req := helloRequest(member.ID, firstUser.OrganizationID)
req.WorkspaceID = &workspaceBuild.Workspace.ID
_, err := client.CreateChat(ctx, req)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Workspace not found or you do not have access to this resource", sdkErr.Message)
})
t.Run("ModelConfigNotAccessibleToOwner", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
provider := createAIProviderForTest(t, client, "openai-compat", "test-api-key")
privateConfig := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: provider.ID, Valid: true}, OrganizationID: firstUser.OrganizationID,
Model: "private-" + uuid.NewString(), Enabled: true, GroupACL: database.ChatACL{},
})
_, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
// The admin can read the private model; the member cannot, and
// chatd would silently fall back to the default at run time.
req := helloRequest(member.ID, firstUser.OrganizationID)
req.ModelConfigID = &privateConfig.ID
_, err := client.CreateChat(ctx, req)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid model_config_id: model config not found or disabled.", sdkErr.Message)
})
t.Run("OrgAdminForbidden", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
orgAdminClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID, rbac.ScopedRoleOrgAdmin(firstUser.OrganizationID))
orgAdminClient := codersdk.NewExperimentalClient(orgAdminClientRaw)
_, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
// Org admins hold org-scoped chat:create, but a chat runs with its
// owner's credentials, so acting as another user needs site-wide
// authority.
_, err := orgAdminClient.CreateChat(ctx, helloRequest(member.ID, firstUser.OrganizationID))
requireSDKError(t, err, http.StatusForbidden)
})
t.Run("MemberForbidden", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
_, other := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
_, err := memberClient.CreateChat(ctx, helloRequest(other.ID, firstUser.OrganizationID))
requireSDKError(t, err, http.StatusForbidden)
})
t.Run("OwnerNotInOrganization", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
otherOrg := dbgen.Organization(t, db, database.Organization{})
_, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
_, err := client.CreateChat(ctx, helloRequest(member.ID, otherOrg.ID))
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Chat owner must be an active member of the organization.", sdkErr.Message)
})
t.Run("OwnerNotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
_, err := client.CreateChat(ctx, helloRequest(uuid.New(), firstUser.OrganizationID))
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Chat owner must be an active member of the organization.", sdkErr.Message)
})
t.Run("OwnerSuspended", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
_, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
_, err := client.UpdateUserStatus(ctx, member.ID.String(), codersdk.UserStatusSuspended)
require.NoError(t, err)
_, err = client.CreateChat(ctx, helloRequest(member.ID, firstUser.OrganizationID))
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Chat owner must be an active member of the organization.", sdkErr.Message)
})
t.Run("OwnerWithoutChatPermission", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Organization service accounts deliberately hold no chat permissions.
serviceAccount := dbgen.User(t, db, database.User{IsServiceAccount: true})
dbgen.OrganizationMember(t, db, database.OrganizationMember{
OrganizationID: firstUser.OrganizationID,
UserID: serviceAccount.ID,
})
_, err := client.CreateChat(ctx, helloRequest(serviceAccount.ID, firstUser.OrganizationID))
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Chat owner does not have permission to use chats.", sdkErr.Message)
})
t.Run("OwnerWithCreateOnlyChatPermission", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
client, _ := newChatClientWithDatabase(t, func(opts *coderdtest.Options) {
opts.Database = rawDB
opts.Pubsub = pubsub
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// A custom role can grant chat:create without read or update.
role, err := rawDB.InsertCustomRole(ctx, database.InsertCustomRoleParams{
Name: testutil.GetRandomName(t),
DisplayName: "Chat Creator",
OrganizationID: uuid.NullUUID{UUID: firstUser.OrganizationID, Valid: true},
OrgPermissions: database.CustomRolePermissions{{
ResourceType: rbac.ResourceChat.Type,
Action: policy.ActionCreate,
}},
})
require.NoError(t, err)
serviceAccount := dbgen.User(t, rawDB, database.User{IsServiceAccount: true})
dbgen.OrganizationMember(t, rawDB, database.OrganizationMember{
OrganizationID: firstUser.OrganizationID,
UserID: serviceAccount.ID,
Roles: []string{role.Name},
})
_, err = client.CreateChat(ctx, helloRequest(serviceAccount.ID, firstUser.OrganizationID))
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Chat owner does not have permission to use chats.", sdkErr.Message)
})
}
// TestChats_ForceOnMCPServerEnforced is the endpoint-level regression
// test for Cure53 CDM-02-010: a regular user who strips force_on MCP
// server IDs from mcp_server_ids when creating a chat or sending a
// message must not be able to exclude those servers.
func TestChats_ForceOnMCPServerEnforced(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// An admin marks an MCP server as Force On.
forced, err := client.CreateMCPServerConfig(ctx, firstUser.OrganizationID, codersdk.CreateMCPServerConfigRequest{
DisplayName: "Forced Server",
Slug: "forced-server",
Transport: "streamable_http",
URL: "https://mcp.example.com/forced",
AuthType: "none",
Availability: "force_on",
Enabled: true,
ToolAllowList: []string{},
ToolDenyList: []string{},
})
require.NoError(t, err)
// A regular member tampers with the request by clearing
// mcp_server_ids (Cure53 CDM-02-010 reproduction).
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat, err := memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "test message",
}},
MCPServerIDs: []uuid.UUID{},
})
require.NoError(t, err)
require.Contains(t, chat.MCPServerIDs, forced.ID,
"force_on MCP server must be enforced on chat creation")
// Sending a message with an emptied list must not remove the
// forced server either.
_, err = memberClient.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "second message",
}},
MCPServerIDs: &[]uuid.UUID{},
})
require.NoError(t, err)
chatResult, err := memberClient.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Contains(t, chatResult.MCPServerIDs, forced.ID,
"force_on MCP server must survive a tampered mcp_server_ids update")
}
func TestPostChats_ClientType(t *testing.T) {
t.Parallel()
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
newChat := func(t *testing.T, clientType codersdk.ChatClientType) codersdk.Chat {
t.Helper()
ctx := testutil.Context(t, testutil.WaitLong)
chat, err := memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "client type test",
}},
ClientType: clientType,
})
require.NoError(t, err)
return chat
}
t.Run("DefaultIsAPI", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
// Omit ClientType entirely — should default to "api".
chat := newChat(t, "")
require.Equal(t, codersdk.ChatClientTypeAPI, chat.ClientType)
got, err := memberClient.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, codersdk.ChatClientTypeAPI, got.ClientType)
})
t.Run("ExplicitAPI", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
chat := newChat(t, codersdk.ChatClientTypeAPI)
require.Equal(t, codersdk.ChatClientTypeAPI, chat.ClientType)
got, err := memberClient.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, codersdk.ChatClientTypeAPI, got.ClientType)
})
t.Run("ExplicitUI", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
chat := newChat(t, codersdk.ChatClientTypeUI)
require.Equal(t, codersdk.ChatClientTypeUI, chat.ClientType)
got, err := memberClient.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, codersdk.ChatClientTypeUI, got.ClientType)
})
t.Run("InvalidClientType", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, err := memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "bad client type",
}},
ClientType: "bogus",
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "Invalid client_type")
})
}
func TestListChats(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
firstChatA, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "first owner chat",
},
},
})
require.NoError(t, err)
firstChatB, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "second owner chat",
},
},
})
require.NoError(t, err)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
memberDBChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: member.ID,
LastModelConfigID: modelConfig.ID,
Title: "member chat only",
})
chats, err := client.ListChats(ctx, nil)
require.NoError(t, err)
require.Len(t, chats, 2)
chatIndexes := make(map[uuid.UUID]int, len(chats))
chatsByID := make(map[uuid.UUID]codersdk.Chat, len(chats))
for i, chat := range chats {
chatIndexes[chat.ID] = i
chatsByID[chat.ID] = chat
require.Equal(t, firstUser.UserID, chat.OwnerID)
require.Equal(t, modelConfig.ID, chat.LastModelConfigID)
// The chat may have been picked up by the chat worker
// before we list, so accept any status it may have
// reached by now.
require.Contains(t, []codersdk.ChatStatus{
codersdk.ChatStatusRunning,
codersdk.ChatStatusError,
codersdk.ChatStatusWaiting,
}, chat.Status, "unexpected chat status: %s", chat.Status)
require.NotZero(t, chat.CreatedAt)
require.NotZero(t, chat.UpdatedAt)
require.Nil(t, chat.ParentChatID)
require.Nil(t, chat.WorkspaceID)
require.NotNil(t, chat.RootChatID)
require.Equal(t, chat.ID, *chat.RootChatID)
require.NotNil(t, chat.DiffStatus)
require.Equal(t, chat.ID, chat.DiffStatus.ChatID)
}
require.Contains(t, chatsByID, firstChatA.ID)
require.Contains(t, chatsByID, firstChatB.ID)
require.NotContains(t, chatsByID, memberDBChat.ID)
require.Equal(t, "first owner chat", chatsByID[firstChatA.ID].Title)
require.Equal(t, "second owner chat", chatsByID[firstChatB.ID].Title)
for i := 1; i < len(chats); i++ {
require.False(t, chats[i-1].UpdatedAt.Before(chats[i].UpdatedAt))
}
// The list is already verified as sorted by UpdatedAt
// descending (loop above). We intentionally do NOT
// compare positions using the creation-time UpdatedAt
// values because the chat worker may pick up a chat and
// mutate UpdatedAt between CreateChat and ListChats.
memberChats, err := memberClient.ListChats(ctx, nil)
require.NoError(t, err)
require.Len(t, memberChats, 1)
require.Equal(t, memberDBChat.ID, memberChats[0].ID)
require.Equal(t, member.ID, memberChats[0].OwnerID)
require.Equal(t, "member chat only", memberChats[0].Title)
require.NotNil(t, memberChats[0].RootChatID)
require.Equal(t, memberChats[0].ID, *memberChats[0].RootChatID)
require.NotNil(t, memberChats[0].DiffStatus)
require.Equal(t, memberChats[0].ID, memberChats[0].DiffStatus.ChatID)
})
t.Run("SourceCreatedByMeAndSharedWithMeExcludesUnsharedReadableChats", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
ownerClientRaw, owner := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID, rbac.RoleOwner())
ownerClient := codersdk.NewExperimentalClient(ownerClientRaw)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
ownedChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: owner.ID,
LastModelConfigID: modelConfig.ID,
Title: "owner created chat",
Status: database.ChatStatusWaiting,
})
sharedChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: member.ID,
LastModelConfigID: modelConfig.ID,
Title: "member shared chat",
Status: database.ChatStatusWaiting,
})
unsharedReadableChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "unshared readable chat",
Status: database.ChatStatusWaiting,
})
err := db.UpdateChatACLByID(dbauthz.As(ctx, rbac.Subject{
ID: member.ID.String(),
Roles: rbac.RoleIdentifiers{rbac.RoleOwner()},
Scope: rbac.ScopeAll,
}), database.UpdateChatACLByIDParams{
ID: sharedChat.ID,
UserACL: database.ChatACL{
owner.ID.String(): database.ChatACLEntry{Permissions: []policy.Action{policy.ActionRead}},
},
GroupACL: database.ChatACL{},
})
require.NoError(t, err)
ownerChats, err := ownerClient.ListChats(ctx, &codersdk.ListChatsOptions{
Query: "source:created_by_me,shared_with_me",
})
require.NoError(t, err)
ownerChatIDs := make(map[uuid.UUID]struct{}, len(ownerChats))
for _, chat := range ownerChats {
ownerChatIDs[chat.ID] = struct{}{}
}
require.Contains(t, ownerChatIDs, ownedChat.ID)
require.Contains(t, ownerChatIDs, sharedChat.ID)
require.NotContains(t, ownerChatIDs, unsharedReadableChat.ID)
sharedOnlyChats, err := ownerClient.ListChats(ctx, &codersdk.ListChatsOptions{
Source: codersdk.ChatListSourceSharedWithMe,
})
require.NoError(t, err)
sharedOnlyChatIDs := make(map[uuid.UUID]struct{}, len(sharedOnlyChats))
for _, chat := range sharedOnlyChats {
sharedOnlyChatIDs[chat.ID] = struct{}{}
}
require.Contains(t, sharedOnlyChatIDs, sharedChat.ID)
require.NotContains(t, sharedOnlyChatIDs, ownedChat.ID)
require.NotContains(t, sharedOnlyChatIDs, unsharedReadableChat.ID)
memberChats, err := memberClient.ListChats(ctx, &codersdk.ListChatsOptions{
Query: "source:created_by_me,shared_with_me",
})
require.NoError(t, err)
memberChatIDs := make(map[uuid.UUID]struct{}, len(memberChats))
for _, chat := range memberChats {
memberChatIDs[chat.ID] = struct{}{}
}
require.Contains(t, memberChatIDs, sharedChat.ID)
require.NotContains(t, memberChatIDs, ownedChat.ID)
require.NotContains(t, memberChatIDs, unsharedReadableChat.ID)
})
t.Run("OrgMemberCanAccessOwnChats", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: member.ID,
LastModelConfigID: modelConfig.ID,
Title: "member chat",
})
chats, err := memberClient.ListChats(ctx, nil)
require.NoError(t, err)
require.Len(t, chats, 1)
require.Equal(t, chat.ID, chats[0].ID)
err = memberClient.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Title: ptr.Ref("new title"),
})
require.NoError(t, err)
})
t.Run("Unauthenticated", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
unauthenticatedClient := codersdk.NewExperimentalClient(codersdk.New(client.URL))
_, err := unauthenticatedClient.ListChats(ctx, nil)
requireSDKError(t, err, http.StatusUnauthorized)
})
t.Run("Pagination", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Insert chats with a terminal status so the chatd
// processor never acquires them and never bumps
// updated_at. The GetChats cursor subquery re-reads the
// cursor row's updated_at, so a concurrent bump would
// shift the cursor position between page requests.
const totalChats = 5
createdChatIDs := make([]uuid.UUID, 0, totalChats)
for i := range totalChats {
dbChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: fmt.Sprintf("chat-%d", i),
Status: database.ChatStatusWaiting,
})
createdChatIDs = append(createdChatIDs, dbChat.ID)
}
// Fetch first page with limit=2.
page1, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Pagination: codersdk.Pagination{Limit: 2},
})
require.NoError(t, err)
require.Len(t, page1, 2)
// Fetch second page using after_id from last item of page 1.
page2, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Pagination: codersdk.Pagination{
AfterID: uuid.MustParse(page1[len(page1)-1].ID.String()),
Limit: 2,
},
})
require.NoError(t, err)
require.Len(t, page2, 2)
// Ensure page1 and page2 have no overlap.
page1IDs := make(map[uuid.UUID]struct{})
for _, c := range page1 {
page1IDs[c.ID] = struct{}{}
}
for _, c := range page2 {
_, overlap := page1IDs[c.ID]
require.False(t, overlap, "page2 should not contain items from page1")
}
// Fetch third page — should have 1 remaining chat.
page3, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Pagination: codersdk.Pagination{
AfterID: uuid.MustParse(page2[len(page2)-1].ID.String()),
Limit: 2,
},
})
require.NoError(t, err)
require.Len(t, page3, 1)
// All 5 chats should be accounted for.
allIDs := make(map[uuid.UUID]struct{})
for _, c := range append(append(page1, page2...), page3...) {
allIDs[c.ID] = struct{}{}
}
for _, id := range createdChatIDs {
_, found := allIDs[id]
require.True(t, found, "chat %s should appear in paginated results", id)
}
// Fetch with offset=3, limit=2 — should return 2 chats.
offsetPage, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Pagination: codersdk.Pagination{Offset: 3, Limit: 2},
})
require.NoError(t, err)
require.Len(t, offsetPage, 2)
// No limit should return all chats.
allChats, err := client.ListChats(ctx, nil)
require.NoError(t, err)
require.Len(t, allChats, totalChats)
})
// Test that a pinned chat with an old updated_at appears on page 1.
t.Run("PinnedOnFirstPage", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Insert chats directly with a terminal status: see
// the Pagination subtest for the cursor-race rationale.
// Direct insertion also avoids spawning 51 background
// chat processors, which causes timeouts under -race.
pinnedDBChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "pinned-chat",
Status: database.ChatStatusWaiting,
})
// Fill page 1 with newer chats so the pinned chat
// would normally be pushed off the first page
// (default limit 50).
const fillerCount = 51
for i := range fillerCount {
_ = dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: fmt.Sprintf("filler-%d", i),
Status: database.ChatStatusWaiting,
})
}
// Pin the earliest chat.
err := client.UpdateChat(ctx, pinnedDBChat.ID, codersdk.UpdateChatRequest{
PinOrder: ptr.Ref(int32(1)),
})
require.NoError(t, err)
// Fetch page 1 with default limit (50).
page1, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Pagination: codersdk.Pagination{Limit: 50},
})
require.NoError(t, err)
// The pinned chat must appear on page 1.
page1IDs := make(map[uuid.UUID]struct{}, len(page1))
for _, c := range page1 {
page1IDs[c.ID] = struct{}{}
}
_, found := page1IDs[pinnedDBChat.ID]
require.True(t, found, "pinned chat should appear on page 1")
// The pinned chat should be the first item in the list.
require.Equal(t, pinnedDBChat.ID, page1[0].ID, "pinned chat should be first")
})
// Test cursor pagination with a mix of pinned and unpinned chats.
t.Run("CursorWithPins", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Insert chats directly with a terminal status: see
// the Pagination subtest for the cursor-race rationale.
const totalChats = 5
createdChatIDs := make([]uuid.UUID, 0, totalChats)
for i := range totalChats {
dbChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: fmt.Sprintf("cursor-pin-chat-%d", i),
Status: database.ChatStatusWaiting,
})
createdChatIDs = append(createdChatIDs, dbChat.ID)
}
// Pin the first two chats (oldest updated_at).
// PinChatByID and UpdateChatPinOrder do not touch
// updated_at, so the cursor ordering stays stable.
err := client.UpdateChat(ctx, createdChatIDs[0], codersdk.UpdateChatRequest{
PinOrder: ptr.Ref(int32(1)),
})
require.NoError(t, err)
err = client.UpdateChat(ctx, createdChatIDs[1], codersdk.UpdateChatRequest{
PinOrder: ptr.Ref(int32(1)),
})
require.NoError(t, err)
// Paginate with limit=2 using cursor (after_id).
const pageSize = 2
maxPages := totalChats/pageSize + 2
var allPaginated []codersdk.Chat
var afterID uuid.UUID
for range maxPages {
opts := &codersdk.ListChatsOptions{
Pagination: codersdk.Pagination{Limit: pageSize},
}
if afterID != uuid.Nil {
opts.AfterID = afterID
}
page, listErr := client.ListChats(ctx, opts)
require.NoError(t, listErr)
if len(page) == 0 {
break
}
allPaginated = append(allPaginated, page...)
afterID = page[len(page)-1].ID
}
// All chats should appear exactly once.
seenIDs := make(map[uuid.UUID]struct{}, len(allPaginated))
for _, c := range allPaginated {
_, dup := seenIDs[c.ID]
require.False(t, dup, "chat %s appeared more than once", c.ID)
seenIDs[c.ID] = struct{}{}
}
require.Len(t, seenIDs, totalChats, "all chats should appear in paginated results")
// Pinned chats should come before unpinned ones, and
// within the pinned group, lower pin_order sorts first.
pinnedSeen := false
unpinnedSeen := false
for _, c := range allPaginated {
if c.PinOrder > 0 {
require.False(t, unpinnedSeen, "pinned chat %s appeared after unpinned chat", c.ID)
pinnedSeen = true
} else {
unpinnedSeen = true
}
}
require.True(t, pinnedSeen, "at least one pinned chat should exist")
// Verify within-pinned ordering: pin_order=1 before
// pin_order=2 (the -pin_order DESC column).
require.Equal(t, createdChatIDs[0], allPaginated[0].ID,
"pin_order=1 chat should be first")
require.Equal(t, createdChatIDs[1], allPaginated[1].ID,
"pin_order=2 chat should be second")
})
t.Run("ChildChatsEmbeddedNotStandalone", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Create a parent chat via the API.
parentChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "root chat with children",
},
},
})
require.NoError(t, err)
// Insert child chats directly via the database.
child1 := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "child one",
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
child2 := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "child two",
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
// Also create a standalone root chat to verify it still appears.
standalone, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "standalone root chat",
},
},
})
require.NoError(t, err)
chats, err := client.ListChats(ctx, nil)
require.NoError(t, err)
// Only root chats should appear at the top level.
rootIDs := make(map[uuid.UUID]struct{}, len(chats))
for _, c := range chats {
rootIDs[c.ID] = struct{}{}
require.Nil(t, c.ParentChatID, "top-level entry should have no parent")
}
require.Contains(t, rootIDs, parentChat.ID)
require.Contains(t, rootIDs, standalone.ID)
require.NotContains(t, rootIDs, child1.ID, "child1 should not appear at top level")
require.NotContains(t, rootIDs, child2.ID, "child2 should not appear at top level")
// Find the parent in the list and verify children are embedded.
var parent codersdk.Chat
for _, c := range chats {
if c.ID == parentChat.ID {
parent = c
break
}
}
require.Len(t, parent.Children, 2, "parent should embed 2 children")
// Children are ordered by created_at DESC (newest first).
childIDs := []uuid.UUID{parent.Children[0].ID, parent.Children[1].ID}
require.Equal(t, child2.ID, childIDs[0])
require.Equal(t, child1.ID, childIDs[1])
// Verify each child has correct parent/root references.
for _, child := range parent.Children {
require.NotNil(t, child.ParentChatID)
require.Equal(t, parentChat.ID, *child.ParentChatID)
require.NotNil(t, child.RootChatID)
require.Equal(t, parentChat.ID, *child.RootChatID)
}
// Standalone root chat should have an empty children slice.
for _, c := range chats {
if c.ID == standalone.ID {
require.NotNil(t, c.Children)
require.Empty(t, c.Children)
break
}
}
})
t.Run("PaginationCountsOnlyRootChats", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Create 3 root chats, each with 2 children.
for i := range 3 {
parent, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: fmt.Sprintf("parent %d", i),
},
},
})
require.NoError(t, err)
for j := range 2 {
_ = dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: fmt.Sprintf("child %d-%d", i, j),
ParentChatID: uuid.NullUUID{UUID: parent.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parent.ID, Valid: true},
})
}
}
// Request with limit=2: should get 2 root chats (not 2 of
// the 9 total chats). Each root should have its children.
chats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Pagination: codersdk.Pagination{Limit: 2},
})
require.NoError(t, err)
require.Len(t, chats, 2, "limit should apply to root chats only")
for _, c := range chats {
require.Nil(t, c.ParentChatID)
require.Len(t, c.Children, 2, "each root should embed its 2 children")
}
})
t.Run("DiffURLFilter", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Helper that creates a chat (root or child) with a diff status URL.
create := func(title, url string, parentID uuid.NullUUID) database.Chat {
rootID := parentID
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: title,
ParentChatID: parentID,
RootChatID: rootID,
})
if url != "" {
staleAt := time.Now().UTC().Add(time.Hour).Truncate(time.Second)
_, err := db.UpsertChatDiffStatusReference(
dbauthz.AsSystemRestricted(ctx),
database.UpsertChatDiffStatusReferenceParams{
ChatID: chat.ID,
Url: sql.NullString{String: url, Valid: true},
GitBranch: "feature/test",
GitRemoteOrigin: "git@github.com:coder/coder.git",
StaleAt: staleAt,
},
)
require.NoError(t, err)
}
return chat
}
// Root chat directly linked to the target PR.
rootWithPR := create("root with pr", "https://github.com/coder/coder/pull/1", uuid.NullUUID{})
// Root chat whose sub-agent owns the PR. The filter should still
// surface the parent because the URL lives on a descendant.
rootWithChildPR := create("root with child pr", "", uuid.NullUUID{})
_ = create(
"sub-agent with pr",
"https://github.com/coder/coder/pull/2",
uuid.NullUUID{UUID: rootWithChildPR.ID, Valid: true},
)
// Root chat with an unrelated PR; should not match either filter.
_ = create("unrelated pr", "https://github.com/coder/coder/pull/999", uuid.NullUUID{})
// Root chat with no diff status at all.
_ = create("no diff", "", uuid.NullUUID{})
// Archived root chat that points at the same URL as `rootWithPR`.
// Used to verify the archived filter and the diff_url filter
// compose at the SQL layer rather than ignoring each other.
archivedWithPR := create(
"archived with pr",
"https://github.com/coder/coder/pull/3",
uuid.NullUUID{},
)
require.NoError(t, client.UpdateChat(ctx, archivedWithPR.ID, codersdk.UpdateChatRequest{
Archived: ptr.Ref(true),
}))
t.Run("MatchesRoot", func(t *testing.T) {
chats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `diff_url:"https://github.com/coder/coder/pull/1"`,
})
require.NoError(t, err)
require.Len(t, chats, 1)
require.Equal(t, rootWithPR.ID, chats[0].ID)
})
t.Run("MatchesViaSubAgent", func(t *testing.T) {
chats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `diff_url:"https://github.com/coder/coder/pull/2"`,
})
require.NoError(t, err)
require.Len(t, chats, 1, "root chat should surface even when only a child has the PR")
require.Equal(t, rootWithChildPR.ID, chats[0].ID)
})
t.Run("CaseInsensitive", func(t *testing.T) {
chats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `diff_url:"HTTPS://GITHUB.COM/CODER/CODER/PULL/1"`,
})
require.NoError(t, err)
require.Len(t, chats, 1)
require.Equal(t, rootWithPR.ID, chats[0].ID)
})
t.Run("NoMatch", func(t *testing.T) {
chats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `diff_url:"https://github.com/coder/coder/pull/424242"`,
})
require.NoError(t, err)
require.Empty(t, chats)
})
t.Run("InvalidURL", func(t *testing.T) {
_, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `diff_url:"ftp://example.com/x"`,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.NotEmpty(t, sdkErr.Validations, "expected validation error")
require.Equal(t, "diff_url", sdkErr.Validations[0].Field)
})
t.Run("ArchivedFilteredOut", func(t *testing.T) {
// Default archived filter is false, so an archived chat with
// a matching diff URL must not surface.
chats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `diff_url:"https://github.com/coder/coder/pull/3"`,
})
require.NoError(t, err)
require.Empty(t, chats, "archived chat must not match the default filter")
})
t.Run("ArchivedTrueComposes", func(t *testing.T) {
chats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `archived:true diff_url:"https://github.com/coder/coder/pull/3"`,
})
require.NoError(t, err)
require.Len(t, chats, 1)
require.Equal(t, archivedWithPR.ID, chats[0].ID)
})
})
}
func TestListChatModels(t *testing.T) {
t.Parallel()
providerByID := func(t *testing.T, response codersdk.OrganizationChatModelsResponse, id uuid.UUID) codersdk.ChatModelProviderDescriptor {
t.Helper()
for _, provider := range response.Providers {
if provider.ID == id {
return provider
}
}
t.Fatalf("provider %s not found", id)
return codersdk.ChatModelProviderDescriptor{}
}
containsModel := func(response codersdk.OrganizationChatModelsResponse, id uuid.UUID) bool {
return slices.ContainsFunc(response.Models, func(model codersdk.ChatModel) bool { return model.ID == id })
}
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
model := createChatModel(t, client)
response, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, containsModel(response, model.ID))
require.True(t, providerByID(t, response, model.AIProviderID).Available)
})
t.Run("DeniedSameOrganizationEnabledModelIsHidden", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
provider := createAIProviderForTest(t, client, "openai-compat", "test-api-key")
privateConfig := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: provider.ID, Valid: true}, OrganizationID: firstUser.OrganizationID,
Model: "private-" + uuid.NewString(), Enabled: true, GroupACL: database.ChatACL{},
})
memberRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
response, err := codersdk.NewExperimentalClient(memberRaw).ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.False(t, containsModel(response, privateConfig.ID))
})
t.Run("NonDefaultOrgIncludesOnlyLocalModels", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
provider := createAIProviderForTest(t, client, "openai-compat", "test-api-key")
defaultConfig := createChatModel(t, client)
chatOrg := dbgen.Organization(t, db, database.Organization{IsDefault: false})
thirdOrg := dbgen.Organization(t, db, database.Organization{IsDefault: false})
contextLimit := int64(4096)
local, err := client.CreateChatModel(ctx, chatOrg.ID, codersdk.CreateChatModelRequest{AIProviderID: &provider.ID, Model: "local-" + uuid.NewString(), ContextLimit: &contextLimit})
require.NoError(t, err)
third, err := client.CreateChatModel(ctx, thirdOrg.ID, codersdk.CreateChatModelRequest{AIProviderID: &provider.ID, Model: "third-" + uuid.NewString(), ContextLimit: &contextLimit})
require.NoError(t, err)
memberRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, chatOrg.ID)
response, err := codersdk.NewExperimentalClient(memberRaw).ChatModels(ctx, chatOrg.ID)
require.NoError(t, err)
require.True(t, containsModel(response, local.ID))
require.False(t, containsModel(response, defaultConfig.ID))
require.False(t, containsModel(response, third.ID))
})
t.Run("Unauthenticated", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_, err := codersdk.NewExperimentalClient(codersdk.New(client.URL)).ChatModels(ctx, firstUser.OrganizationID)
requireSDKError(t, err, http.StatusUnauthorized)
})
t.Run("CopilotOnlyUnsupported", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
provider := createAIProviderForTest(t, client, string(codersdk.AIProviderTypeCopilot), "")
response, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.False(t, providerByID(t, response, provider.ID).Available)
require.Equal(t, []codersdk.ChatUnsupportedProvider{{Provider: "copilot", DisplayName: "GitHub Copilot"}}, response.UnsupportedProviders)
})
t.Run("SupportedProviderHasNoUnsupportedEntry", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
response, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.Empty(t, response.UnsupportedProviders)
})
t.Run("CentralOnlyProviderAvailable", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
model := createChatModel(t, client)
response, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, providerByID(t, response, model.AIProviderID).Available)
})
t.Run("UserOnlyProviderRequiresUserKey", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
provider := createAIProviderForTest(t, client, "anthropic", "")
response, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
descriptor := providerByID(t, response, provider.ID)
require.False(t, descriptor.Available)
require.Equal(t, codersdk.ChatModelProviderUnavailableReasonUserAPIKeyRequired, descriptor.UnavailableReason)
_, err = client.UpsertUserAIProviderKey(ctx, "me", provider.ID, codersdk.CreateUserAIProviderKeyRequest{APIKey: "user-key"})
require.NoError(t, err)
response, err = client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, providerByID(t, response, provider.ID).Available)
})
t.Run("CentralAndUserWithFallback", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
provider := createAIProviderForTest(t, client, "google", "provider-key")
response, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, providerByID(t, response, provider.ID).Available)
_, err = client.UpsertUserAIProviderKey(ctx, "me", provider.ID, codersdk.CreateUserAIProviderKeyRequest{APIKey: "user-key"})
require.NoError(t, err)
response, err = client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, providerByID(t, response, provider.ID).Available)
})
t.Run("SameTypeProvidersUseExactCredentialStatus", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
availableProvider := createAIProviderForTest(t, client, "openai", "available-key")
unavailableProvider := createAIProviderForTest(t, client, "openai", "")
response, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, providerByID(t, response, availableProvider.ID).Available)
unavailable := providerByID(t, response, unavailableProvider.ID)
require.False(t, unavailable.Available)
require.NotEmpty(t, unavailable.UnavailableReason)
})
t.Run("UserCredentialsAreCallerIsolated", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
provider := createAIProviderForTest(t, client, "anthropic", "")
otherRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
other := codersdk.NewExperimentalClient(otherRaw)
_, err := client.UpsertUserAIProviderKey(ctx, "me", provider.ID, codersdk.CreateUserAIProviderKeyRequest{APIKey: "owner-key"})
require.NoError(t, err)
ownerResponse, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
otherResponse, err := other.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, providerByID(t, ownerResponse, provider.ID).Available)
require.True(t, providerByID(t, ownerResponse, provider.ID).HasUserAPIKey)
require.False(t, providerByID(t, otherResponse, provider.ID).Available)
require.False(t, providerByID(t, otherResponse, provider.ID).HasUserAPIKey)
})
t.Run("IncludesOnlyDefaultOrganizationModels", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
provider := createAIProviderForTest(t, client, "openai-compat", "test-api-key")
contextLimit := int64(4096)
defaultConfig, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{AIProviderID: &provider.ID, Model: "default-" + uuid.NewString(), ContextLimit: &contextLimit})
require.NoError(t, err)
otherOrg := dbgen.Organization(t, db, database.Organization{IsDefault: false})
other := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{AIProviderID: uuid.NullUUID{UUID: provider.ID, Valid: true}, Model: "other-" + uuid.NewString(), OrganizationID: otherOrg.ID})
response, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, containsModel(response, defaultConfig.ID))
require.False(t, containsModel(response, other.ID))
})
t.Run("DisabledProvidersAndModelsRemainVisible", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
provider := createAIProviderForTest(t, client, "openai", "test-key")
contextLimit := int64(4096)
enabledModel, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{AIProviderID: &provider.ID, Model: "enabled-" + uuid.NewString(), ContextLimit: &contextLimit})
require.NoError(t, err)
disabledModel, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{AIProviderID: &provider.ID, Model: "disabled-" + uuid.NewString(), ContextLimit: &contextLimit})
require.NoError(t, err)
_, err = client.UpdateChatModel(ctx, firstUser.OrganizationID, disabledModel.ID, codersdk.UpdateChatModelRequest{Enabled: ptr.Ref(false)})
require.NoError(t, err)
response, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, containsModel(response, enabledModel.ID))
require.True(t, slices.ContainsFunc(response.Models, func(model codersdk.ChatModel) bool {
return model.ID == disabledModel.ID && !model.Enabled
}))
_, err = client.UpdateAIProvider(ctx, provider.ID.String(), codersdk.UpdateAIProviderRequest{Enabled: ptr.Ref(false)})
require.NoError(t, err)
response, err = client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, containsModel(response, enabledModel.ID))
require.True(t, containsModel(response, disabledModel.ID))
disabledProvider := providerByID(t, response, provider.ID)
require.False(t, disabledProvider.Enabled)
require.False(t, disabledProvider.Available)
})
}
func TestListChats_Search(t *testing.T) {
t.Parallel()
setup := func(t *testing.T) (context.Context, *codersdk.ExperimentalClient, database.Store, codersdk.CreateFirstUserResponse, codersdk.ChatModel) {
t.Helper()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
return ctx, client, db, firstUser, modelConfig
}
createChat := func(t *testing.T, db database.Store, firstUser codersdk.CreateFirstUserResponse, modelConfigID uuid.UUID, title string) database.Chat {
t.Helper()
return dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfigID,
Title: title,
Status: database.ChatStatusWaiting,
})
}
insertMessage := func(t *testing.T, db database.Store, firstUser codersdk.CreateFirstUserResponse, modelConfigID, chatID uuid.UUID, text string) {
t.Helper()
content, err := json.Marshal([]map[string]string{{"type": "text", "text": text}})
require.NoError(t, err)
dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chatID,
CreatedBy: uuid.NullUUID{UUID: firstUser.UserID, Valid: true},
ModelConfigID: uuid.NullUUID{UUID: modelConfigID, Valid: true},
Role: database.ChatMessageRoleUser,
Visibility: database.ChatMessageVisibilityBoth,
Content: pqtype.NullRawMessage{RawMessage: content, Valid: true},
})
}
backfillSearchTsv := func(ctx context.Context, t *testing.T, db database.Store) {
t.Helper()
_, err := db.BackfillChatMessagesSearchTsv(dbauthz.AsSystemRestricted(ctx), 1000)
require.NoError(t, err)
}
chatIDs := func(chats []codersdk.Chat) map[uuid.UUID]struct{} {
ids := make(map[uuid.UUID]struct{}, len(chats))
for _, chat := range chats {
ids[chat.ID] = struct{}{}
}
return ids
}
t.Run("MatchesTitleAndMessageBody", func(t *testing.T) {
t.Parallel()
ctx, client, db, firstUser, modelConfig := setup(t)
titleMatch := createChat(t, db, firstUser, modelConfig.ID, "kubernetes upgrade notes")
bodyMatch := createChat(t, db, firstUser, modelConfig.ID, "plain title")
insertMessage(t, db, firstUser, modelConfig.ID, bodyMatch.ID, "restart the kubernetes cluster")
noMatch := createChat(t, db, firstUser, modelConfig.ID, "unrelated chat")
insertMessage(t, db, firstUser, modelConfig.ID, noMatch.ID, "terraform apply failure")
backfillSearchTsv(ctx, t, db)
chats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `search:"kubernetes"`,
})
require.NoError(t, err)
ids := chatIDs(chats)
require.Contains(t, ids, titleMatch.ID)
require.Contains(t, ids, bodyMatch.ID)
require.NotContains(t, ids, noMatch.ID)
// The 'english' config stems both sides, so an inflected query
// form matches the stored words.
chats, err = client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `search:"restarting"`,
})
require.NoError(t, err)
require.Contains(t, chatIDs(chats), bodyMatch.ID)
})
t.Run("NoSearchableWordsReturnsEmpty", func(t *testing.T) {
t.Parallel()
ctx, client, db, firstUser, modelConfig := setup(t)
// Message search uses the 'english' config, which drops
// stopwords: search:"or" tokenizes to no lexemes and matches
// nothing, just like search:"!!!". The title must not contain the
// searched words because title search keeps the 'simple' config,
// which retains stopwords. The control query proves the empty
// results come from tokenization, not missing data.
control := createChat(t, db, firstUser, modelConfig.ID, "plain title")
insertMessage(t, db, firstUser, modelConfig.ID, control.ID, "fix this or that")
backfillSearchTsv(ctx, t, db)
chats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `search:"fix"`,
})
require.NoError(t, err)
require.Contains(t, chatIDs(chats), control.ID)
chats, err = client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `search:"or"`,
})
require.NoError(t, err)
require.Empty(t, chats)
chats, err = client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `search:"!!!"`,
})
require.NoError(t, err)
require.Empty(t, chats)
})
t.Run("ComposesWithRepoFilterAndArchivedDefault", func(t *testing.T) {
t.Parallel()
ctx, client, db, firstUser, modelConfig := setup(t)
linkRepo := func(chatID uuid.UUID, remote string) {
t.Helper()
_, err := db.UpsertChatDiffStatusReference(
dbauthz.AsSystemRestricted(ctx),
database.UpsertChatDiffStatusReferenceParams{
ChatID: chatID,
GitBranch: "main",
GitRemoteOrigin: remote,
StaleAt: time.Now().UTC().Add(time.Hour),
},
)
require.NoError(t, err)
}
bothMatch := createChat(t, db, firstUser, modelConfig.ID, "kubernetes in coder repo")
linkRepo(bothMatch.ID, "git@github.com:acme/widget.git")
searchOnly := createChat(t, db, firstUser, modelConfig.ID, "kubernetes elsewhere")
linkRepo(searchOnly.ID, "git@github.com:acme/other.git")
repoOnly := createChat(t, db, firstUser, modelConfig.ID, "plain title")
linkRepo(repoOnly.ID, "git@github.com:acme/widget.git")
// Matches via message body, not title, so composition also covers
// search_tsv.
bodyMatch := createChat(t, db, firstUser, modelConfig.ID, "quiet title")
linkRepo(bodyMatch.ID, "git@github.com:acme/widget.git")
insertMessage(t, db, firstUser, modelConfig.ID, bodyMatch.ID, "kubernetes rollout stuck")
bodyMatchWrongRepo := createChat(t, db, firstUser, modelConfig.ID, "quiet title two")
linkRepo(bodyMatchWrongRepo.ID, "git@github.com:acme/other.git")
insertMessage(t, db, firstUser, modelConfig.ID, bodyMatchWrongRepo.ID, "kubernetes rollout stuck")
archivedMatch := createChat(t, db, firstUser, modelConfig.ID, "kubernetes archived")
linkRepo(archivedMatch.ID, "git@github.com:acme/widget.git")
_, err := db.ArchiveChatByID(dbauthz.AsSystemRestricted(ctx), archivedMatch.ID)
require.NoError(t, err)
backfillSearchTsv(ctx, t, db)
chats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `repo:widget search:"kubernetes"`,
})
require.NoError(t, err)
ids := chatIDs(chats)
require.Contains(t, ids, bothMatch.ID)
require.Contains(t, ids, bodyMatch.ID)
require.NotContains(t, ids, bodyMatchWrongRepo.ID)
require.NotContains(t, ids, searchOnly.ID)
require.NotContains(t, ids, repoOnly.ID)
// Archived chats stay hidden unless archived:true is requested.
require.NotContains(t, ids, archivedMatch.ID)
})
t.Run("NoSearchTermUnchanged", func(t *testing.T) {
t.Parallel()
ctx, client, db, firstUser, modelConfig := setup(t)
chat := createChat(t, db, firstUser, modelConfig.ID, "kubernetes upgrade notes")
other := createChat(t, db, firstUser, modelConfig.ID, "unrelated chat")
chats, err := client.ListChats(ctx, nil)
require.NoError(t, err)
ids := chatIDs(chats)
require.Contains(t, ids, chat.ID)
require.Contains(t, ids, other.ID)
})
t.Run("MutualExclusionWithTitleReturns400", func(t *testing.T) {
t.Parallel()
ctx, client, _, _, _ := setup(t)
_, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: `search:alpha title:beta`,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Len(t, sdkErr.Validations, 1)
require.Equal(t, "search", sdkErr.Validations[0].Field)
require.Contains(t, sdkErr.Validations[0].Detail, `"title"`)
})
}
func TestWatchChats(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
conn, err := client.Dial(ctx, "/api/v2/chats/watch", nil)
require.NoError(t, err)
defer conn.Close(websocket.StatusNormalClosure, "done")
createdChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "watch route created event",
},
},
})
require.NoError(t, err)
for {
var payload codersdk.ChatWatchEvent
err = wsjson.Read(ctx, conn, &payload)
require.NoError(t, err)
if payload.Kind == codersdk.ChatWatchEventKindCreated &&
payload.Chat.ID == createdChat.ID {
break
}
}
})
t.Run("CreatedEventIncludesAllChatFields", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
conn, err := client.Dial(ctx, "/api/v2/chats/watch", nil)
require.NoError(t, err)
defer conn.Close(websocket.StatusNormalClosure, "done")
createdChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "watch route fields completeness test",
},
},
})
require.NoError(t, err)
var got codersdk.Chat
testutil.Eventually(ctx, t, func(_ context.Context) bool {
var payload codersdk.ChatWatchEvent
if readErr := wsjson.Read(ctx, conn, &payload); readErr != nil {
return false
}
if payload.Kind == codersdk.ChatWatchEventKindCreated &&
payload.Chat.ID == createdChat.ID {
got = payload.Chat
return true
}
return false
}, testutil.IntervalFast, "expected a created event for chat %s", createdChat.ID)
require.Equal(t, createdChat.ID, got.ID)
require.Equal(t, createdChat.OwnerID, got.OwnerID)
require.Equal(t, modelConfig.ID, got.LastModelConfigID)
require.Equal(t, createdChat.Title, got.Title)
// CreateChat inserts new chats in the running state under the
// chatstate state machine, so the created event carries running.
require.Equal(t, codersdk.ChatStatusRunning, got.Status)
require.NotNil(t, got.RootChatID)
require.Equal(t, createdChat.ID, *got.RootChatID)
require.NotZero(t, got.CreatedAt)
require.NotZero(t, got.UpdatedAt)
})
t.Run("DiffStatusChangeIncludesDiffStatusAndOmitsInjectedContext", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
DeploymentValues: coderdtest.DeploymentValues(t),
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
db := api.Database
chatDaemon := api.ChatDaemon()
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Insert a chat and a diff status row.
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "diff status watch test",
})
refreshedAt := time.Now().UTC().Truncate(time.Second)
staleAt := refreshedAt.Add(time.Hour)
_, err := db.UpsertChatDiffStatusReference(
dbauthz.AsSystemRestricted(ctx),
database.UpsertChatDiffStatusReferenceParams{
ChatID: chat.ID,
Url: sql.NullString{String: "https://github.com/coder/coder/pull/99", Valid: true},
GitBranch: "feature/test",
GitRemoteOrigin: "git@github.com:coder/coder.git",
StaleAt: staleAt,
},
)
require.NoError(t, err)
_, err = db.UpsertChatDiffStatus(
dbauthz.AsSystemRestricted(ctx),
database.UpsertChatDiffStatusParams{
ChatID: chat.ID,
Url: sql.NullString{String: "https://github.com/coder/coder/pull/99", Valid: true},
GitBranch: "feature/test",
GitRemoteOrigin: "git@github.com:coder/coder.git",
PullRequestState: sql.NullString{String: "open", Valid: true},
Additions: 42,
Deletions: 7,
ChangedFiles: 5,
RefreshedAt: refreshedAt,
StaleAt: staleAt,
},
)
require.NoError(t, err)
// Open the watch WebSocket.
conn, err := client.Dial(ctx, "/api/v2/chats/watch", nil)
require.NoError(t, err)
defer conn.Close(websocket.StatusNormalClosure, "done")
err = chatDaemon.PublishDiffStatusChange(dbauthz.AsChatd(ctx), chat.ID, codersdk.DiffStatusRef{
RemoteOrigin: "git@github.com:coder/coder.git",
GitBranch: "feature/test",
})
require.NoError(t, err)
var received codersdk.ChatWatchEvent
for {
err = wsjson.Read(ctx, conn, &received)
require.NoError(t, err)
if received.Kind == codersdk.ChatWatchEventKindDiffStatusChange &&
received.Chat.ID == chat.ID {
break
}
}
// Verify the event carries the full DiffStatus.
require.NotNil(t, received.Chat.DiffStatus, "diff_status_change event must include DiffStatus")
ds := received.Chat.DiffStatus
require.Equal(t, chat.ID, ds.ChatID)
require.NotNil(t, ds.URL)
require.Equal(t, "https://github.com/coder/coder/pull/99", *ds.URL)
require.NotNil(t, ds.PullRequestState)
require.Equal(t, "open", *ds.PullRequestState)
require.EqualValues(t, 42, ds.Additions)
require.EqualValues(t, 7, ds.Deletions)
require.EqualValues(t, 5, ds.ChangedFiles)
require.NotNil(t, received.ChangedDiffStatus)
require.Equal(t, "git@github.com:coder/coder.git", received.ChangedDiffStatus.Ref.RemoteOrigin)
require.Equal(t, "feature/test", received.ChangedDiffStatus.Ref.GitBranch)
require.NotNil(t, received.ChangedDiffStatus.Status)
require.NotNil(t, received.ChangedDiffStatus.Status.URL)
require.Equal(
t,
"https://github.com/coder/coder/pull/99",
*received.ChangedDiffStatus.Status.URL,
)
require.NotNil(t, received.ChangedDiffStatus.Status.PullRequestState)
require.Equal(
t,
"open",
*received.ChangedDiffStatus.Status.PullRequestState,
)
require.EqualValues(t, 42, received.ChangedDiffStatus.Status.Additions)
require.EqualValues(t, 7, received.ChangedDiffStatus.Status.Deletions)
require.EqualValues(t, 5, received.ChangedDiffStatus.Status.ChangedFiles)
})
t.Run("ArchiveAndUnarchiveEmitEventsForDescendants", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db, api := newChatClientWithAPIAndDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
parentChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "watch root chat",
},
},
})
require.NoError(t, err)
// The parent chat is created via the API, so the chat worker moves
// it to running. Archiving is only allowed from a terminal state,
// so wait for it to settle before archiving below.
coderdtest.WaitForChatSettled(ctx, t, api, parentChat.ID)
childOne := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "watch child 1",
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
childTwo := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "watch child 2",
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
conn, err := client.Dial(ctx, "/api/v2/chats/watch", nil)
require.NoError(t, err)
defer conn.Close(websocket.StatusNormalClosure, "done")
collectLifecycleEvents := func(expectedKind codersdk.ChatWatchEventKind) map[uuid.UUID]codersdk.ChatWatchEvent {
t.Helper()
events := make(map[uuid.UUID]codersdk.ChatWatchEvent, 3)
for len(events) < 3 {
var payload codersdk.ChatWatchEvent
err = wsjson.Read(ctx, conn, &payload)
require.NoError(t, err)
if payload.Kind != expectedKind {
continue
}
events[payload.Chat.ID] = payload
}
return events
}
assertLifecycleEvents := func(events map[uuid.UUID]codersdk.ChatWatchEvent, archived bool) {
t.Helper()
require.Len(t, events, 3)
for _, chatID := range []uuid.UUID{parentChat.ID, childOne.ID, childTwo.ID} {
payload, ok := events[chatID]
require.True(t, ok, "missing event for chat %s", chatID)
require.Equal(t, archived, payload.Chat.Archived)
}
}
err = client.UpdateChat(ctx, parentChat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)})
require.NoError(t, err)
deletedEvents := collectLifecycleEvents(codersdk.ChatWatchEventKindDeleted)
assertLifecycleEvents(deletedEvents, true)
err = client.UpdateChat(ctx, parentChat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(false)})
require.NoError(t, err)
createdEvents := collectLifecycleEvents(codersdk.ChatWatchEventKindCreated)
assertLifecycleEvents(createdEvents, false)
})
t.Run("Unauthenticated", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
unauthenticatedClient := codersdk.New(client.URL)
res, err := unauthenticatedClient.Request(
ctx,
http.MethodGet,
"/api/v2/chats/watch",
nil,
)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
})
}
func TestUserAIProviderKeys(t *testing.T) {
t.Parallel()
createOpenAIProvider := func(t *testing.T, client *codersdk.ExperimentalClient, name string, enabled bool, apiKeys ...string) codersdk.AIProvider {
t.Helper()
provider, err := client.CreateAIProvider(testutil.Context(t, testutil.WaitLong), codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeOpenAI,
Name: name,
Enabled: enabled,
BaseURL: "https://api.openai.example.com/v1",
APIKeys: apiKeys,
})
require.NoError(t, err)
return provider
}
findUserAIProviderKeyConfig := func(
t *testing.T,
configs []codersdk.UserAIProviderKeyConfig,
providerID uuid.UUID,
) *codersdk.UserAIProviderKeyConfig {
t.Helper()
for i := range configs {
if configs[i].Provider.ID == providerID {
return &configs[i]
}
}
return nil
}
t.Run("SelfServiceLifecycle", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
provider := createOpenAIProvider(t, adminClient, "test-user-key-"+uuid.NewString(), true, "test-provider-api-key")
configs, err := memberClient.ListUserAIProviderKeyConfigs(ctx, "me")
require.NoError(t, err)
cfg := findUserAIProviderKeyConfig(t, configs, provider.ID)
require.NotNil(t, cfg)
require.False(t, cfg.HasUserAPIKey)
require.True(t, cfg.HasProviderAPIKey)
require.True(t, cfg.BYOKEnabled)
cfgValue, err := memberClient.UpsertUserAIProviderKey(ctx, "me", provider.ID, codersdk.CreateUserAIProviderKeyRequest{APIKey: "test-user-api-key"})
require.NoError(t, err)
require.Equal(t, provider.ID, cfgValue.Provider.ID)
require.True(t, cfgValue.HasUserAPIKey)
require.True(t, cfgValue.HasProviderAPIKey)
require.True(t, cfgValue.BYOKEnabled)
configs, err = memberClient.ListUserAIProviderKeyConfigs(ctx, "me")
require.NoError(t, err)
cfg = findUserAIProviderKeyConfig(t, configs, provider.ID)
require.NotNil(t, cfg)
require.True(t, cfg.HasUserAPIKey)
cfgValue, err = memberClient.UpsertUserAIProviderKey(ctx, "me", provider.ID, codersdk.CreateUserAIProviderKeyRequest{APIKey: "replacement-user-api-key"})
require.NoError(t, err)
require.Equal(t, provider.ID, cfgValue.Provider.ID)
require.True(t, cfgValue.HasUserAPIKey)
configs, err = memberClient.ListUserAIProviderKeyConfigs(ctx, "me")
require.NoError(t, err)
cfg = findUserAIProviderKeyConfig(t, configs, provider.ID)
require.NotNil(t, cfg)
require.True(t, cfg.HasUserAPIKey)
require.NoError(t, memberClient.DeleteUserAIProviderKey(ctx, "me", provider.ID))
configs, err = memberClient.ListUserAIProviderKeyConfigs(ctx, "me")
require.NoError(t, err)
cfg = findUserAIProviderKeyConfig(t, configs, provider.ID)
require.NotNil(t, cfg)
require.False(t, cfg.HasUserAPIKey)
})
t.Run("ListsDisabledProviderWithSavedUserKey", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
provider := createOpenAIProvider(t, adminClient, "test-disabled-saved-user-key-"+uuid.NewString(), true)
_, err := memberClient.UpsertUserAIProviderKey(ctx, "me", provider.ID, codersdk.CreateUserAIProviderKeyRequest{APIKey: "test-user-api-key"})
require.NoError(t, err)
enabled := false
_, err = adminClient.UpdateAIProvider(ctx, provider.ID.String(), codersdk.UpdateAIProviderRequest{Enabled: &enabled})
require.NoError(t, err)
configs, err := memberClient.ListUserAIProviderKeyConfigs(ctx, "me")
require.NoError(t, err)
cfg := findUserAIProviderKeyConfig(t, configs, provider.ID)
require.NotNil(t, cfg)
require.False(t, cfg.Provider.Enabled)
require.True(t, cfg.HasUserAPIKey)
})
t.Run("RejectsDisabledProvider", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
provider := createOpenAIProvider(t, adminClient, "test-disabled-user-key-"+uuid.NewString(), false)
_, err := memberClient.UpsertUserAIProviderKey(ctx, "me", provider.ID, codersdk.CreateUserAIProviderKeyRequest{APIKey: "test-user-api-key"})
sdkErr := requireSDKError(t, err, http.StatusPreconditionFailed)
require.Equal(t, "AI provider is disabled.", sdkErr.Message)
})
t.Run("AcceptsBedrockProvider", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
provider, err := adminClient.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeBedrock,
Name: "test-bedrock-user-key-" + uuid.NewString(),
Enabled: true,
BaseURL: "https://bedrock-runtime.us-east-1.amazonaws.com",
Settings: codersdk.AIProviderSettings{
Bedrock: &codersdk.AIProviderBedrockSettings{
Region: "us-east-1",
Model: "anthropic.claude-3-5-sonnet",
SmallFastModel: "anthropic.claude-3-5-haiku",
},
},
})
require.NoError(t, err)
// Bedrock providers accept a user-supplied Bedrock API key, which the
// AI gateway forwards as a bearer token.
cfg, err := memberClient.UpsertUserAIProviderKey(ctx, "me", provider.ID, codersdk.CreateUserAIProviderKeyRequest{APIKey: "test-user-api-key"})
require.NoError(t, err)
require.True(t, cfg.HasUserAPIKey)
configs, err := memberClient.ListUserAIProviderKeyConfigs(ctx, "me")
require.NoError(t, err)
listed := findUserAIProviderKeyConfig(t, configs, provider.ID)
require.NotNil(t, listed)
require.True(t, listed.HasUserAPIKey)
})
t.Run("RejectsLargeAPIKey", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
provider := createOpenAIProvider(t, adminClient, "test-large-user-key-"+uuid.NewString(), true)
_, err := memberClient.UpsertUserAIProviderKey(ctx, "me", provider.ID, codersdk.CreateUserAIProviderKeyRequest{APIKey: strings.Repeat("x", 10241)})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "API key too large.", sdkErr.Message)
})
t.Run("RejectsWhitespaceAPIKey", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
provider := createOpenAIProvider(t, adminClient, "test-whitespace-user-key-"+uuid.NewString(), true)
_, err := memberClient.UpsertUserAIProviderKey(ctx, "me", provider.ID, codersdk.CreateUserAIProviderKeyRequest{APIKey: " "})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "API key must not contain leading or trailing whitespace.", sdkErr.Message)
})
t.Run("BYOKDisabledRejectsUpsertAndAllowsDelete", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
values := coderdtest.DeploymentValues(t)
values.AI.BridgeConfig.AllowBYOK = serpent.Bool(false)
// The aibridged reloader logs at error level when it sees a provider
// configured with no API key and BYOK disabled. That state is the
// scenario under test, so suppress its error logs here.
logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: true})
client := newChatClient(t, func(o *coderdtest.Options) {
o.DeploymentValues = values
o.Logger = &logger
})
_ = coderdtest.CreateFirstUser(t, client.Client)
provider := createOpenAIProvider(t, client, "test-byok-disabled-"+uuid.NewString(), true)
_, err := client.UpsertUserAIProviderKey(ctx, "me", provider.ID, codersdk.CreateUserAIProviderKeyRequest{APIKey: "test-user-api-key"})
sdkErr := requireSDKError(t, err, http.StatusForbidden)
require.Equal(t, "BYOK is disabled.", sdkErr.Message)
configs, err := client.ListUserAIProviderKeyConfigs(ctx, "me")
require.NoError(t, err)
cfg := findUserAIProviderKeyConfig(t, configs, provider.ID)
require.NotNil(t, cfg)
require.False(t, cfg.BYOKEnabled)
require.NoError(t, client.DeleteUserAIProviderKey(ctx, "me", provider.ID))
})
}
func TestListChatModelConfigs(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
configs, err := client.ChatModels(ctx, modelConfig.OrganizationID)
require.NoError(t, err)
require.NotEmpty(t, configs.Models)
require.NotEmpty(t, configs.Providers)
require.Empty(t, configs.UnsupportedProviders)
found := false
for _, config := range configs.Models {
if config.ID == modelConfig.ID {
found = true
require.Equal(t, modelConfig.AIProviderID, config.AIProviderID)
require.Equal(t, modelConfig.Model, config.Model)
require.True(t, config.IsDefault)
}
}
require.True(t, found)
})
t.Run("CollectionIncludesDisabledModelConfigs", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
aiProvider := createAIProviderForTest(t, client, "openai", "test-api-key")
contextLimit := int64(4096)
enabled := false
disabledConfig, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-disabled",
DisplayName: "GPT-4o Disabled",
Enabled: &enabled,
ContextLimit: &contextLimit,
})
require.NoError(t, err)
require.False(t, disabledConfig.Enabled)
configs, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, slices.ContainsFunc(configs.Models, func(config codersdk.ChatModel) bool {
return config.ID == disabledConfig.ID && !config.Enabled
}))
})
t.Run("OrganizationMemberSeesReadableModels", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
readableConfig := createChatModel(t, adminClient)
privateConfig := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: readableConfig.AIProviderID, Valid: true},
Model: "private-" + uuid.NewString(),
OrganizationID: firstUser.OrganizationID,
GroupACL: database.ChatACL{},
})
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
configs, err := memberClient.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
modelIDs := make([]uuid.UUID, 0, len(configs.Models))
for _, config := range configs.Models {
modelIDs = append(modelIDs, config.ID)
}
require.Contains(t, modelIDs, readableConfig.ID)
require.NotContains(t, modelIDs, privateConfig.ID)
})
t.Run("BedrockDescriptorReportsEffectiveCredentials", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
provider := dbgen.AIProvider(t, db, database.AIProvider{
Type: database.AIProviderTypeBedrock,
})
models, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
for _, descriptor := range models.Providers {
if descriptor.ID == provider.ID {
require.False(t, descriptor.HasAPIKey)
require.False(t, descriptor.HasUserAPIKey)
require.True(t, descriptor.HasEffectiveAPIKey)
require.True(t, descriptor.Available)
require.Empty(t, descriptor.UnavailableReason)
return
}
}
t.Fatal("bedrock provider descriptor not found")
})
t.Run("ComputerUseProvider", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
anthropicProvider := dbgen.AIProvider(t, db, database.AIProvider{Type: database.AIProviderTypeAnthropic})
bedrockProvider := dbgen.AIProvider(t, db, database.AIProvider{Type: database.AIProviderTypeBedrock})
compatProvider := dbgen.AIProvider(t, db, database.AIProvider{Type: database.AIProviderTypeOpenaiCompat})
want := map[uuid.UUID]codersdk.ChatComputerUseProvider{}
for _, tc := range []struct {
provider database.AIProvider
model string
want codersdk.ChatComputerUseProvider
}{
{provider: anthropicProvider, model: "claude-opus-5-5", want: codersdk.ChatComputerUseProviderAnthropic},
{provider: bedrockProvider, model: "us.anthropic.claude-opus-5-5", want: codersdk.ChatComputerUseProviderAnthropic},
{provider: bedrockProvider, model: "openai.gpt-5.4"},
{provider: compatProvider, model: "claude-opus-5-5", want: codersdk.ChatComputerUseProviderOpenAICompat},
} {
config := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: tc.provider.ID, Valid: true},
Model: tc.model,
OrganizationID: firstUser.OrganizationID,
})
want[config.ID] = tc.want
}
models, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
got := map[uuid.UUID]codersdk.ChatComputerUseProvider{}
for _, model := range models.Models {
if _, ok := want[model.ID]; ok {
got[model.ID] = model.ComputerUseProvider
}
}
require.Equal(t, want, got)
})
}
func TestGetChatModel(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
got, err := client.ChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID)
require.NoError(t, err)
require.Equal(t, modelConfig.ID, got.ID)
})
t.Run("WrongOrganizationConcealedForAllItemActions", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
wrongOrganization := dbgen.Organization(t, db, database.Organization{IsDefault: false})
for _, tc := range []struct {
name string
method string
body any
}{
{name: "Get", method: http.MethodGet},
{name: "Patch", method: http.MethodPatch, body: codersdk.UpdateChatModelRequest{DisplayName: "wrong organization"}},
{name: "Delete", method: http.MethodDelete},
} {
t.Run(tc.name, func(t *testing.T) {
res, err := client.Request(ctx, tc.method, fmt.Sprintf(
"/api/v2/organizations/%s/chats/models/%s",
wrongOrganization.ID,
modelConfig.ID,
), tc.body)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
}
stored, err := db.GetChatModelConfigByID(dbauthz.AsSystemRestricted(ctx), modelConfig.ID)
require.NoError(t, err)
require.Equal(t, modelConfig.DisplayName, stored.DisplayName)
})
t.Run("OrganizationMemberCanReadSharedModel", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
modelConfig := createChatModel(t, adminClient)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
got, err := memberClient.ChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID)
require.NoError(t, err)
require.Equal(t, modelConfig.ID, got.ID)
})
t.Run("OrganizationMemberCannotReadPrivateModel", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
sharedConfig := createChatModel(t, adminClient)
privateConfig := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: sharedConfig.AIProviderID, Valid: true},
Model: "private-" + uuid.NewString(),
OrganizationID: firstUser.OrganizationID,
GroupACL: database.ChatACL{},
})
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
_, err := memberClient.ChatModel(ctx, privateConfig.OrganizationID, privateConfig.ID)
requireSDKError(t, err, http.StatusNotFound)
})
}
func TestCreateChatModelConfig(t *testing.T) {
t.Parallel()
t.Run("UnauthorizedPrincipalCannotProbeProviderState", func(t *testing.T) {
t.Parallel()
// The write is authorized before any privileged provider lookup, so
// a principal without create-in-org gets an identical denial whether
// the provider ID is missing, disabled, or configured: no provider
// state is disclosed.
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
configuredProvider := createAIProviderForTest(t, client, "openai", "test-api-key")
disabledProvider := createAIProviderForTest(t, client, "google", "test-api-key-2")
enabled := false
_, err := client.UpdateAIProvider(ctx, disabledProvider.ID.String(), codersdk.UpdateAIProviderRequest{
Enabled: &enabled,
})
require.NoError(t, err)
for _, tc := range []struct {
name string
providerID uuid.UUID
}{
{"missing", uuid.New()},
{"disabled", disabledProvider.ID},
{"configured", configuredProvider.ID},
} {
t.Run(tc.name, func(t *testing.T) {
contextLimit := int64(4096)
_, err := memberClient.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &tc.providerID,
Model: "probe-" + tc.name,
ContextLimit: &contextLimit,
})
sdkErr := requireSDKError(t, err, http.StatusForbidden)
require.Equal(t, "Forbidden.", sdkErr.Message)
})
}
})
t.Run("NormalCreateConcealsHiddenAndMissingOrganizations", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
provider := createAIProviderForTest(t, adminClient, "openai", "test-api-key")
hiddenOrganization := dbgen.Organization(t, db, database.Organization{IsDefault: false})
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
contextLimit := int64(4096)
var concealedMessage string
for _, organizationID := range []uuid.UUID{hiddenOrganization.ID, uuid.New()} {
_, err := memberClient.CreateChatModel(ctx, organizationID, codersdk.CreateChatModelRequest{
AIProviderID: &provider.ID,
Model: "concealed-" + uuid.NewString(),
ContextLimit: &contextLimit,
})
sdkErr := requireSDKError(t, err, http.StatusNotFound)
if concealedMessage == "" {
concealedMessage = sdkErr.Message
}
require.Equal(t, concealedMessage, sdkErr.Message)
}
configs, err := adminClient.ChatModels(ctx, hiddenOrganization.ID)
require.NoError(t, err)
require.Empty(t, configs.Models)
})
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
aiProvider := createAIProviderForTest(t, client, "openai", "test-api-key")
contextLimit := int64(4096)
isDefault := true
modelConfig, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
IsDefault: &isDefault,
})
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, modelConfig.ID)
require.Equal(t, aiProvider.ID, modelConfig.AIProviderID)
require.Equal(t, "gpt-4o-mini", modelConfig.Model)
require.EqualValues(t, 4096, modelConfig.ContextLimit)
require.True(t, modelConfig.IsDefault)
configs, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.Len(t, configs.Models, 1)
})
t.Run("ProviderReferenceLockFailureUsesCreateErrorText", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, store := newChatClientWithModelConfigHookStore(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
aiProvider := createAIProviderForTest(t, client, "openai", "test-api-key")
store.armFailProviderReferenceLock(aiProvider.ID)
contextLimit := int64(4096)
_, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
})
sdkErr := requireSDKError(t, err, http.StatusInternalServerError)
require.Equal(t, "Failed to create chat model config.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, "get AI provider for create")
require.NotContains(t, sdkErr.Detail, "get AI provider for update")
})
t.Run("ConcurrentCreatesElectSingleDefault", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
aiProvider := createAIProviderForTest(t, client, "openai", "test-api-key")
// Concurrent creators race to self-elect a default while one claims
// it via a follow-up update, mirroring a terraform apply. Unserialized,
// the losers 409 on the single-default unique index.
const creators = 10
contextLimit := int64(4096)
var claimed codersdk.ChatModel
var eg errgroup.Group
for i := range creators - 1 {
eg.Go(func() error {
_, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: fmt.Sprintf("gpt-4o-mini-%d", i),
ContextLimit: &contextLimit,
})
return err
})
}
eg.Go(func() error {
created, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o",
ContextLimit: &contextLimit,
})
if err != nil {
return xerrors.Errorf("create claimed config: %w", err)
}
claimed, err = client.UpdateChatModel(ctx, created.OrganizationID, created.ID, codersdk.UpdateChatModelRequest{
IsDefault: ptr.Ref(true),
})
if err != nil {
return xerrors.Errorf("promote claimed config: %w", err)
}
return nil
})
require.NoError(t, eg.Wait())
configs, err := client.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.Len(t, configs.Models, creators)
var defaults []uuid.UUID
for _, cfg := range configs.Models {
if cfg.IsDefault {
defaults = append(defaults, cfg.ID)
}
}
require.Equal(t, []uuid.UUID{claimed.ID}, defaults)
})
t.Run("SuccessCustomOrgRole", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
client := newChatClient(t, func(opts *coderdtest.Options) {
opts.Database = rawDB
opts.Pubsub = pubsub
})
_ = coderdtest.CreateFirstUser(t, client.Client)
defaultOrg, err := rawDB.GetDefaultOrganization(ctx)
require.NoError(t, err)
// A custom org role holding only chat_model_config permissions
// passes write authorization for configs in its org and holds no
// grant anywhere else; org role permissions are scoped to the
// organization the role belongs to.
role, err := rawDB.InsertCustomRole(ctx, database.InsertCustomRoleParams{
Name: testutil.GetRandomName(t),
DisplayName: "Chat Model Config Admin",
OrganizationID: uuid.NullUUID{UUID: defaultOrg.ID, Valid: true},
OrgPermissions: database.CustomRolePermissions{
{
ResourceType: rbac.ResourceChatModelConfig.Type,
Action: policy.ActionCreate,
},
{
ResourceType: rbac.ResourceChatModelConfig.Type,
Action: policy.ActionRead,
},
{
ResourceType: rbac.ResourceChatModelConfig.Type,
Action: policy.ActionUpdate,
},
},
})
require.NoError(t, err)
// An existing org default keeps the create off the self-promotion
// path; the writer below holds no chat_model_config:update grant
// beyond its own org. The owner seeds the provider and the
// default: both operations need site-wide permissions a
// non-owner lacks.
aiProvider := createAIProviderForTest(t, client, "openai", "test-api-key")
_ = createAdditionalChatModel(t, client, "openai", "gpt-4o-existing")
adminClientRaw, adminUser := coderdtest.CreateAnotherUser(
t,
client.Client,
defaultOrg.ID,
)
_, err = client.UpdateOrganizationMemberRoles(
ctx,
defaultOrg.ID,
adminUser.ID.String(),
codersdk.UpdateRoles{Roles: []string{role.Name}},
)
require.NoError(t, err)
adminClient := codersdk.NewExperimentalClient(adminClientRaw)
contextLimit := int64(4096)
modelConfig, err := adminClient.CreateChatModel(ctx, defaultOrg.ID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
})
require.NoError(t, err)
row, err := rawDB.GetChatModelConfigByID(ctx, modelConfig.ID)
require.NoError(t, err)
require.Equal(t, defaultOrg.ID, row.OrganizationID)
require.False(t, row.IsDefault)
require.Equal(
t,
database.ChatACL{
defaultOrg.ID.String(): {Permissions: []policy.Action{policy.ActionRead}},
},
row.GroupACL,
)
require.Equal(t, database.ChatACL{}, row.UserACL)
})
// An organization role can manage the full model lifecycle. Default
// election must not select another organization's config.
t.Run("OrgRoleWritesThroughLifecycle", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
client := newChatClient(t, func(opts *coderdtest.Options) {
opts.Database = rawDB
opts.Pubsub = pubsub
})
_ = coderdtest.CreateFirstUser(t, client.Client)
defaultOrg, err := rawDB.GetDefaultOrganization(ctx)
require.NoError(t, err)
// The writer role holds chat_model_config permissions in the
// default org and nothing else: user-scoped member permissions do
// not carry the org-wide create grant the route needs, so the role
// must supply every action the lifecycle touches.
role, err := rawDB.InsertCustomRole(ctx, database.InsertCustomRoleParams{
Name: testutil.GetRandomName(t),
DisplayName: "Chat Model Config Admin",
OrganizationID: uuid.NullUUID{UUID: defaultOrg.ID, Valid: true},
OrgPermissions: database.CustomRolePermissions{
{
ResourceType: rbac.ResourceChatModelConfig.Type,
Action: policy.ActionCreate,
},
{
ResourceType: rbac.ResourceChatModelConfig.Type,
Action: policy.ActionRead,
},
{
ResourceType: rbac.ResourceChatModelConfig.Type,
Action: policy.ActionUpdate,
},
{
ResourceType: rbac.ResourceChatModelConfig.Type,
Action: policy.ActionDelete,
},
},
})
require.NoError(t, err)
aiProvider := createAIProviderForTest(t, client, "openai", "test-api-key")
writerClientRaw, writerUser := coderdtest.CreateAnotherUser(
t,
client.Client,
defaultOrg.ID,
)
_, err = client.UpdateOrganizationMemberRoles(
ctx,
defaultOrg.ID,
writerUser.ID.String(),
codersdk.UpdateRoles{Roles: []string{role.Name}},
)
require.NoError(t, err)
writerClient := codersdk.NewExperimentalClient(writerClientRaw)
contextLimit := int64(4096)
defaultConfig, err := writerClient.CreateChatModel(ctx, defaultOrg.ID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
})
require.NoError(t, err)
require.True(t, defaultConfig.IsDefault)
updated, err := writerClient.UpdateChatModel(ctx, defaultConfig.OrganizationID, defaultConfig.ID, codersdk.UpdateChatModelRequest{
DisplayName: "Window Write",
})
require.NoError(t, err)
require.Equal(t, "Window Write", updated.DisplayName)
candidate, err := writerClient.CreateChatModel(ctx, defaultOrg.ID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini-candidate",
ContextLimit: &contextLimit,
})
require.NoError(t, err)
notDefault := false
_, err = writerClient.UpdateChatModel(ctx, defaultConfig.OrganizationID, defaultConfig.ID, codersdk.UpdateChatModelRequest{
IsDefault: &notDefault,
})
require.NoError(t, err)
candidateRow, err := rawDB.GetChatModelConfigByID(ctx, candidate.ID)
require.NoError(t, err)
require.True(t, candidateRow.IsDefault)
err = writerClient.DeleteChatModel(ctx, candidate.OrganizationID, candidate.ID)
require.NoError(t, err)
defaultRow, err := rawDB.GetChatModelConfigByID(ctx, defaultConfig.ID)
require.NoError(t, err)
require.True(t, defaultRow.IsDefault)
promoted, err := writerClient.CreateChatModel(ctx, defaultOrg.ID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini-promoted",
ContextLimit: &contextLimit,
})
require.NoError(t, err)
isDefault := true
_, err = writerClient.UpdateChatModel(ctx, promoted.OrganizationID, promoted.ID, codersdk.UpdateChatModelRequest{
IsDefault: &isDefault,
})
require.NoError(t, err)
promotedRow, err := rawDB.GetChatModelConfigByID(ctx, promoted.ID)
require.NoError(t, err)
require.True(t, promotedRow.IsDefault)
})
t.Run("ReasoningEffortStored", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
aiProvider := createAIProviderForTest(t, client, "openai", "test-api-key")
contextLimit := int64(4096)
modelConfig, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
ModelConfig: &codersdk.ChatModelCallConfig{
ReasoningEffort: &codersdk.ChatModelReasoningEffortConfig{
Default: ptr.Ref("medium"),
Max: ptr.Ref("xhigh"),
},
},
})
require.NoError(t, err)
require.NotNil(t, modelConfig.ModelConfig)
require.NotNil(t, modelConfig.ModelConfig.ReasoningEffort)
require.NotNil(t, modelConfig.ModelConfig.ReasoningEffort.Default)
require.Equal(t, "medium", *modelConfig.ModelConfig.ReasoningEffort.Default)
require.NotNil(t, modelConfig.ModelConfig.ReasoningEffort.Max)
require.Equal(t, "xhigh", *modelConfig.ModelConfig.ReasoningEffort.Max)
require.Equal(t, []string{"none", "minimal", "low", "medium", "high", "xhigh"}, modelConfig.ReasoningEfforts)
})
t.Run("ReasoningEffortRejectsSingleValue", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
aiProvider := createAIProviderForTest(t, client, "openai", "test-api-key")
contextLimit := int64(4096)
_, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
ModelConfig: &codersdk.ChatModelCallConfig{
ReasoningEffort: &codersdk.ChatModelReasoningEffortConfig{
Default: ptr.Ref("high"),
},
},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid model config.", sdkErr.Message)
require.Equal(t, "reasoning_effort.default and reasoning_effort.max must both be set", sdkErr.Detail)
})
t.Run("ReasoningEffortRejectsInvalidValue", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
aiProvider := createAIProviderForTest(t, client, "openai", "test-api-key")
contextLimit := int64(4096)
_, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
ModelConfig: &codersdk.ChatModelCallConfig{
ReasoningEffort: &codersdk.ChatModelReasoningEffortConfig{
Default: ptr.Ref(" HIGH "),
Max: ptr.Ref("high"),
},
},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid model config.", sdkErr.Message)
require.Equal(
t,
`reasoning_effort.default " HIGH " must be one of none, minimal, low, medium, high, xhigh, max`,
sdkErr.Detail,
)
})
t.Run("ReasoningEffortRejectsDefaultAboveMax", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
aiProvider := createAIProviderForTest(t, client, "openai", "test-api-key")
contextLimit := int64(4096)
_, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
ModelConfig: &codersdk.ChatModelCallConfig{
ReasoningEffort: &codersdk.ChatModelReasoningEffortConfig{
Default: ptr.Ref("xhigh"),
Max: ptr.Ref("low"),
},
},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid model config.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, "must not exceed")
})
t.Run("MissingContextLimit", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
aiProvider := createAIProviderForTest(t, client, "openai", "test-api-key")
_, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini",
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Context limit is required.", sdkErr.Message)
})
t.Run("AIProviderIDRequired", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
contextLimit := int64(4096)
_, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "AI provider ID is required.", sdkErr.Message)
})
t.Run("ProviderNotConfigured", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
contextLimit := int64(4096)
missingProviderID := uuid.New()
_, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &missingProviderID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
})
sdkErr := requireSDKError(t, err, http.StatusPreconditionFailed)
require.Equal(t, "AI provider is not configured.", sdkErr.Message)
})
t.Run("WithAIProviderID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
provider, err := client.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeOpenAI,
Name: "test-model-config-provider-" + uuid.NewString(),
Enabled: true,
BaseURL: "https://api.openai.com/v1",
})
require.NoError(t, err)
contextLimit := int64(4096)
modelConfig, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &provider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
})
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, modelConfig.AIProviderID)
require.Equal(t, provider.ID, modelConfig.AIProviderID)
})
t.Run("AIProviderIDNotConfigured", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
missingProviderID := uuid.New()
contextLimit := int64(4096)
_, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &missingProviderID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
})
sdkErr := requireSDKError(t, err, http.StatusPreconditionFailed)
require.Equal(t, "AI provider is not configured.", sdkErr.Message)
})
t.Run("AIProviderIDDisabled", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
provider, err := client.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeOpenAI,
Name: "test-disabled-model-provider-" + uuid.NewString(),
Enabled: false,
BaseURL: "https://api.openai.com/v1",
})
require.NoError(t, err)
contextLimit := int64(4096)
_, err = client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &provider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
})
sdkErr := requireSDKError(t, err, http.StatusPreconditionFailed)
require.Equal(t, "AI provider is disabled.", sdkErr.Message)
})
t.Run("RejectsOpenRouterMisconfiguredAsOpenAI", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
aiProvider, err := client.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeOpenAI,
Name: "openrouter",
Enabled: true,
BaseURL: "https://openrouter.ai/api/v1",
APIKeys: []string{"test-api-key"},
})
require.NoError(t, err)
contextLimit := int64(4096)
_, err = client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "anthropic/claude-opus-4.6",
ContextLimit: &contextLimit,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "OpenRouter-like provider configured as type openai does not support slash-namespaced models.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, "Change the AI provider type to openrouter or openai-compat.")
})
t.Run("ForbiddenForOrganizationMember", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
aiProvider := createAIProviderForTest(t, adminClient, "openai", "test-api-key")
contextLimit := int64(4096)
_, err := memberClient.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
})
// A plain org member holds no chat model config permissions in the
// org, so the create is rejected by the write pre-check before any
// privileged provider lookup.
sdkErr := requireSDKError(t, err, http.StatusForbidden)
require.Equal(t, "Forbidden.", sdkErr.Message)
})
}
func TestUpdateChatModel(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
contextLimit := int64(8192)
updated, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
DisplayName: "GPT-4o Mini Updated",
ContextLimit: &contextLimit,
})
require.NoError(t, err)
require.Equal(t, modelConfig.ID, updated.ID)
require.Equal(t, "GPT-4o Mini Updated", updated.DisplayName)
require.EqualValues(t, 8192, updated.ContextLimit)
configs, err := client.ChatModels(ctx, modelConfig.OrganizationID)
require.NoError(t, err)
require.Len(t, configs.Models, 1)
})
t.Run("SoleConfigRemainsDefaultWhenDemoted", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
updated, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
IsDefault: ptr.Ref(false),
})
require.NoError(t, err)
require.True(t, updated.IsDefault)
defaultConfig, err := db.GetDefaultChatModelConfig(dbauthz.AsSystemRestricted(ctx), firstUser.OrganizationID)
require.NoError(t, err)
require.Equal(t, modelConfig.ID, defaultConfig.ID)
})
t.Run("PromotionLeavesOtherOrganizationDefaultUnchanged", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
defaultConfig := createChatModel(t, client)
candidateConfig := createAdditionalChatModel(
t,
client,
coderdtest.TestChatProviderOpenAICompat,
"promotion-candidate",
)
otherOrg := dbgen.Organization(t, db, database.Organization{})
otherDefault := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
Model: "other-org-default-" + uuid.NewString(),
AIProviderID: uuid.NullUUID{UUID: defaultConfig.AIProviderID, Valid: true},
OrganizationID: otherOrg.ID,
IsDefault: true,
})
updated, err := client.UpdateChatModel(ctx, candidateConfig.OrganizationID, candidateConfig.ID, codersdk.UpdateChatModelRequest{
IsDefault: ptr.Ref(true),
})
require.NoError(t, err)
require.True(t, updated.IsDefault)
orgDefault, err := db.GetDefaultChatModelConfig(dbauthz.AsSystemRestricted(ctx), firstUser.OrganizationID)
require.NoError(t, err)
require.Equal(t, candidateConfig.ID, orgDefault.ID)
unchangedOtherDefault, err := db.GetDefaultChatModelConfig(dbauthz.AsSystemRestricted(ctx), otherOrg.ID)
require.NoError(t, err)
require.Equal(t, otherDefault.ID, unchangedOtherDefault.ID)
})
t.Run("UnchangedProviderWithoutAIProviderID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
updated, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
Model: "gpt-4o-mini-updated",
})
require.NoError(t, err)
require.Equal(t, modelConfig.ID, updated.ID)
require.NotEqual(t, uuid.Nil, updated.AIProviderID)
require.Equal(t, modelConfig.AIProviderID, updated.AIProviderID)
require.Equal(t, "gpt-4o-mini-updated", updated.Model)
})
t.Run("RejectsOpenRouterMisconfiguredAsOpenAI", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
aiProvider, err := client.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeOpenAI,
Name: "openrouter",
Enabled: true,
BaseURL: "https://openrouter.ai/api/v1",
APIKeys: []string{"test-api-key"},
})
require.NoError(t, err)
contextLimit := int64(4096)
modelConfig, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-mini",
ContextLimit: &contextLimit,
})
require.NoError(t, err)
_, err = client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
Model: "anthropic/claude-opus-4.6",
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "OpenRouter-like provider configured as type openai does not support slash-namespaced models.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, "Change the AI provider type to openrouter or openai-compat.")
})
t.Run("AllowsUnrelatedEditOnExistingMisconfiguredOpenAI", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
aiProvider, err := client.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeOpenAI,
Name: "openrouter",
Enabled: true,
BaseURL: "https://openrouter.ai/api/v1",
APIKeys: []string{"test-api-key"},
})
require.NoError(t, err)
modelConfig := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
Model: "anthropic/claude-opus-4.6",
AIProviderID: uuid.NullUUID{UUID: aiProvider.ID, Valid: true},
})
updated, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
DisplayName: "Existing OpenRouter Config",
})
require.NoError(t, err)
require.Equal(t, "Existing OpenRouter Config", updated.DisplayName)
require.Equal(t, modelConfig.Model, updated.Model)
})
t.Run("RejectsProviderChangeToMisconfiguredOpenAI", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
validProvider, err := client.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeOpenrouter,
Name: "openrouter-valid",
Enabled: true,
BaseURL: "https://openrouter.ai/api/v1",
APIKeys: []string{"test-api-key"},
})
require.NoError(t, err)
misconfiguredProvider, err := client.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeOpenAI,
Name: "openrouter",
Enabled: true,
BaseURL: "https://openrouter.ai/api/v1",
APIKeys: []string{"test-api-key"},
})
require.NoError(t, err)
contextLimit := int64(4096)
modelConfig, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &validProvider.ID,
Model: "anthropic/claude-opus-4.6",
ContextLimit: &contextLimit,
})
require.NoError(t, err)
_, err = client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
AIProviderID: &misconfiguredProvider.ID,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "OpenRouter-like provider configured as type openai does not support slash-namespaced models.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, "Change the AI provider type to openrouter or openai-compat.")
})
t.Run("DisablePreservesRecordAndRejectsUseForMembers", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
modelConfig := createChatModel(t, adminClient)
enabled := false
updated, err := adminClient.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
Enabled: &enabled,
})
require.NoError(t, err)
require.Equal(t, modelConfig.ID, updated.ID)
require.False(t, updated.Enabled)
adminConfigs, err := adminClient.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, slices.ContainsFunc(adminConfigs.Models, func(config codersdk.ChatModel) bool {
return config.ID == modelConfig.ID && !config.Enabled
}))
collection, err := memberClient.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, slices.ContainsFunc(collection.Models, func(config codersdk.ChatModel) bool {
return config.ID == modelConfig.ID && !config.Enabled
}))
_, err = memberClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "use a disabled model config",
}},
ModelConfigID: &modelConfig.ID,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid model_config_id: model config not found or disabled.", sdkErr.Message)
})
t.Run("ReEnableUpdatesCollectionDescriptor", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
aiProvider := createAIProviderForTest(t, adminClient, "openai", "test-api-key")
contextLimit := int64(4096)
enabled := false
modelConfig, err := adminClient.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "gpt-4o-reenable",
DisplayName: "GPT-4o Re-enable",
Enabled: &enabled,
ContextLimit: &contextLimit,
})
require.NoError(t, err)
require.False(t, modelConfig.Enabled)
collection, err := memberClient.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, slices.ContainsFunc(collection.Models, func(config codersdk.ChatModel) bool {
return config.ID == modelConfig.ID && !config.Enabled
}))
enabled = true
updated, err := adminClient.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
Enabled: &enabled,
})
require.NoError(t, err)
require.Equal(t, modelConfig.ID, updated.ID)
require.True(t, updated.Enabled)
collection, err = memberClient.ChatModels(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.True(t, slices.ContainsFunc(collection.Models, func(config codersdk.ChatModel) bool {
return config.ID == modelConfig.ID && config.Enabled
}))
})
t.Run("UpdateAIProviderID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
provider, err := client.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeAnthropic,
Name: "test-update-model-provider-" + uuid.NewString(),
Enabled: true,
BaseURL: "https://api.anthropic.com",
})
require.NoError(t, err)
updated, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
AIProviderID: &provider.ID,
Model: "claude-3-5-sonnet-latest",
})
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, updated.AIProviderID)
require.Equal(t, provider.ID, updated.AIProviderID)
})
t.Run("UpdateProviderPreservesAIProviderIDWhenTypeUnchanged", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
provider, err := client.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeAnthropic,
Name: "test-preserve-model-provider-" + uuid.NewString(),
Enabled: true,
BaseURL: "https://api.anthropic.com",
})
require.NoError(t, err)
updated, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
AIProviderID: &provider.ID,
Model: "claude-3-5-sonnet-latest",
})
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, updated.AIProviderID)
updated, err = client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
Model: "claude-3-5-haiku-latest",
})
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, updated.AIProviderID)
require.Equal(t, provider.ID, updated.AIProviderID)
})
t.Run("UpdateAIProviderIDNotConfigured", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
missingProviderID := uuid.New()
_, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
AIProviderID: &missingProviderID,
})
sdkErr := requireSDKError(t, err, http.StatusPreconditionFailed)
require.Equal(t, "AI provider is not configured.", sdkErr.Message)
})
t.Run("UpdateAIProviderIDDisabled", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
provider, err := client.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeOpenAI,
Name: "test-update-disabled-model-provider-" + uuid.NewString(),
Enabled: false,
BaseURL: "https://api.openai.com/v1",
})
require.NoError(t, err)
_, err = client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
AIProviderID: &provider.ID,
})
sdkErr := requireSDKError(t, err, http.StatusPreconditionFailed)
require.Equal(t, "AI provider is disabled.", sdkErr.Message)
})
t.Run("ProviderNotConfigured", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
missingProviderID := uuid.New()
_, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
AIProviderID: &missingProviderID,
})
sdkErr := requireSDKError(t, err, http.StatusPreconditionFailed)
require.Equal(t, "AI provider is not configured.", sdkErr.Message)
})
t.Run("NotFoundWhenTargetRowDisappearsInTx", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, store := newChatClientWithModelConfigHookStore(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
store.armFailNextUpdate(modelConfig.ID)
_, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
DisplayName: "missing in tx",
})
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("InternalServerErrorWhenDefaultCandidateDisappearsInTx", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, store := newChatClientWithModelConfigHookStore(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
defaultConfig := createChatModel(t, client)
aiProvider := createAIProviderForTest(t, client, "anthropic", "candidate-api-key")
contextLimit := int64(4096)
isDefault := false
candidateConfig, err := client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
Model: "claude-3-5-sonnet",
ContextLimit: &contextLimit,
IsDefault: &isDefault,
})
require.NoError(t, err)
store.armFailNextUpdate(candidateConfig.ID)
_, err = client.UpdateChatModel(ctx, defaultConfig.OrganizationID, defaultConfig.ID, codersdk.UpdateChatModelRequest{
IsDefault: ptr.Ref(false),
})
sdkErr := requireSDKError(t, err, http.StatusInternalServerError)
require.Equal(t, "Failed to update chat model config.", sdkErr.Message)
})
t.Run("NotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_, err := client.UpdateChatModel(ctx, firstUser.OrganizationID, uuid.New(), codersdk.UpdateChatModelRequest{
DisplayName: "missing",
})
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("InvalidContextLimit", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
contextLimit := int64(0)
_, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
ContextLimit: &contextLimit,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Context limit must be greater than zero.", sdkErr.Message)
})
// A row that disappears between the pre-read and the locked read must
// 404, not silently no-op the update.
t.Run("NotFoundWhenTargetRowDisappearsAtLockedRead", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, store := newChatClientWithModelConfigHookStore(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
store.armVanishAtLockedRead(modelConfig.ID)
_, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
DisplayName: "vanished before update",
})
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("MergesFromLockedCopy", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, store := newChatClientWithModelConfigHookStore(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
const sentinel = "locked-copy-sentinel-model"
store.armMutateAtLockedRead(modelConfig.ID, sentinel)
updated, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
DisplayName: "only-display-name",
})
require.NoError(t, err)
require.Equal(t, sentinel, updated.Model)
require.Equal(t, "only-display-name", updated.DisplayName)
})
t.Run("StoredProviderDisabledOnModelOnlyUpdate", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
disabled := false
_, err := client.UpdateAIProvider(ctx, modelConfig.AIProviderID.String(), codersdk.UpdateAIProviderRequest{
Enabled: &disabled,
})
require.NoError(t, err)
_, err = client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
Model: "gpt-4o-different",
})
sdkErr := requireSDKError(t, err, http.StatusPreconditionFailed)
require.Equal(t, "AI provider is disabled.", sdkErr.Message)
})
t.Run("StoredProviderMissingOnModelOnlyUpdate", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
err := client.DeleteAIProvider(ctx, modelConfig.AIProviderID.String())
require.NoError(t, err)
_, err = client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
Model: "gpt-4o-different",
})
sdkErr := requireSDKError(t, err, http.StatusPreconditionFailed)
require.Equal(t, "AI provider is not configured.", sdkErr.Message)
})
t.Run("RejectsACLKeys", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
for _, tc := range []struct {
name string
key string
value any
}{
{name: "group_acl/object", key: "group_acl", value: map[string]any{}},
{name: "group_acl/null", key: "group_acl", value: nil},
{name: "user_acl/object", key: "user_acl", value: map[string]any{}},
{name: "user_acl/null", key: "user_acl", value: nil},
} {
t.Run(tc.name, func(t *testing.T) {
res, err := client.Request(ctx, http.MethodPatch, fmt.Sprintf(
"/api/v2/organizations/%s/chats/models/%s",
modelConfig.OrganizationID,
modelConfig.ID,
), map[string]any{tc.key: tc.value})
require.NoError(t, err)
defer res.Body.Close()
err = codersdk.ReadBodyAsError(res)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "nested /acl endpoint")
})
}
})
t.Run("CompressionThresholdOutOfRange", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
_, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
CompressionThreshold: ptr.Ref(int32(150)),
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid compression threshold.", sdkErr.Message)
})
t.Run("CompressionThresholdInRange", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
updated, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
CompressionThreshold: ptr.Ref(int32(55)),
})
require.NoError(t, err)
require.Equal(t, int32(55), updated.CompressionThreshold)
})
t.Run("ModelConfigUpdated", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
updated, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
ModelConfig: &codersdk.ChatModelCallConfig{
ReasoningEffort: &codersdk.ChatModelReasoningEffortConfig{
Default: ptr.Ref("high"),
Max: ptr.Ref("high"),
},
},
})
require.NoError(t, err)
require.NotNil(t, updated.ModelConfig)
require.NotNil(t, updated.ModelConfig.ReasoningEffort)
require.NotNil(t, updated.ModelConfig.ReasoningEffort.Default)
require.Equal(t, "high", *updated.ModelConfig.ReasoningEffort.Default)
})
t.Run("InvalidModelConfigID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
res, err := client.Request(
ctx,
http.MethodPatch,
fmt.Sprintf("/api/v2/organizations/%s/chats/models/not-a-uuid", firstUser.OrganizationID),
codersdk.UpdateChatModelRequest{DisplayName: "ignored"},
)
require.NoError(t, err)
defer res.Body.Close()
err = codersdk.ReadBodyAsError(res)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, `Invalid UUID "not-a-uuid".`, sdkErr.Message)
})
t.Run("ForbiddenForOrganizationMember", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
modelConfig := createChatModel(t, adminClient)
_, err := memberClient.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
DisplayName: "member update",
})
// Action-aware item admission conceals a caller without update access.
sdkErr := requireSDKError(t, err, http.StatusNotFound)
require.Equal(t, "Resource not found or you do not have access to this resource", sdkErr.Message)
})
}
func TestDeleteChatModelConfig(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
err := client.DeleteChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID)
require.NoError(t, err)
configs, err := client.ChatModels(ctx, modelConfig.OrganizationID)
require.NoError(t, err)
for _, config := range configs.Models {
require.NotEqual(t, modelConfig.ID, config.ID)
}
})
t.Run("DeletionLeavesOtherOrganizationDefaultUnchanged", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
defaultConfig := createChatModel(t, client)
candidateConfig := createAdditionalChatModel(
t,
client,
coderdtest.TestChatProviderOpenAICompat,
"delete-candidate",
)
otherOrg := dbgen.Organization(t, db, database.Organization{})
otherDefault := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
Model: "other-org-default-" + uuid.NewString(),
AIProviderID: uuid.NullUUID{UUID: defaultConfig.AIProviderID, Valid: true},
OrganizationID: otherOrg.ID,
IsDefault: true,
})
err := client.DeleteChatModel(ctx, defaultConfig.OrganizationID, defaultConfig.ID)
require.NoError(t, err)
orgDefault, err := db.GetDefaultChatModelConfig(dbauthz.AsSystemRestricted(ctx), firstUser.OrganizationID)
require.NoError(t, err)
require.Equal(t, candidateConfig.ID, orgDefault.ID)
unchangedOtherDefault, err := db.GetDefaultChatModelConfig(dbauthz.AsSystemRestricted(ctx), otherOrg.ID)
require.NoError(t, err)
require.Equal(t, otherDefault.ID, unchangedOtherDefault.ID)
})
// Deleting the default must not promote a config whose provider is
// disabled while a usable candidate exists.
t.Run("PromotesUsableConfigOverDisabledProvider", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
defaultConfig := createChatModel(t, client)
// Same provider type as the enabled candidate with an
// alphabetically earlier model, so it sorts first in the
// reselection order.
createProviderDisabledChatModel(
t,
client,
coderdtest.TestChatProviderOpenAICompat,
"a-provider-disabled-model",
)
enabledConfig := createAdditionalChatModel(
t,
client,
coderdtest.TestChatProviderOpenAICompat,
"z-enabled-model",
)
err := client.DeleteChatModel(ctx, defaultConfig.OrganizationID, defaultConfig.ID)
require.NoError(t, err)
configs, err := client.ChatModels(ctx, defaultConfig.OrganizationID)
require.NoError(t, err)
defaultID := uuid.Nil
for _, config := range configs.Models {
if config.IsDefault {
defaultID = config.ID
}
}
require.Equal(t, enabledConfig.ID, defaultID)
})
t.Run("NotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
err := client.DeleteChatModel(ctx, firstUser.OrganizationID, uuid.New())
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("NotFoundWhenTargetRowDisappearsAtDelete", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, store := newChatClientWithModelConfigHookStore(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
store.armFailNextDelete(modelConfig.ID)
err := client.DeleteChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID)
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("InvalidModelConfigID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
res, err := client.Request(
ctx,
http.MethodDelete,
fmt.Sprintf("/api/v2/organizations/%s/chats/models/not-a-uuid", firstUser.OrganizationID),
nil,
)
require.NoError(t, err)
defer res.Body.Close()
err = codersdk.ReadBodyAsError(res)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, `Invalid UUID "not-a-uuid".`, sdkErr.Message)
})
t.Run("ForbiddenForOrganizationMember", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
modelConfig := createChatModel(t, adminClient)
err := memberClient.DeleteChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID)
// Action-aware item admission conceals a caller without delete access.
sdkErr := requireSDKError(t, err, http.StatusNotFound)
require.Equal(t, "Resource not found or you do not have access to this resource", sdkErr.Message)
})
}
func TestGetChat(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
createdChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "get chat route payload",
},
},
})
require.NoError(t, err)
chatResult, err := client.GetChat(ctx, createdChat.ID)
require.NoError(t, err)
messagesResult, err := client.GetChatMessages(ctx, createdChat.ID, nil)
require.NoError(t, err)
require.Equal(t, createdChat.ID, chatResult.ID)
require.Equal(t, firstUser.UserID, chatResult.OwnerID)
require.Equal(t, modelConfig.ID, chatResult.LastModelConfigID)
require.Equal(t, "get chat route payload", chatResult.Title)
require.NotZero(t, chatResult.CreatedAt)
require.NotZero(t, chatResult.UpdatedAt)
require.NotEmpty(t, messagesResult.Messages)
require.Empty(t, messagesResult.QueuedMessages)
foundUserMessage := false
for _, message := range messagesResult.Messages {
require.Equal(t, createdChat.ID, message.ChatID)
require.NotEqual(t, codersdk.ChatMessageRoleSystem, message.Role)
for _, part := range message.Content {
if message.Role == codersdk.ChatMessageRoleUser &&
part.Type == codersdk.ChatMessagePartTypeText &&
part.Text == "get chat route payload" {
foundUserMessage = true
}
}
}
require.True(t, foundUserMessage)
})
t.Run("NotFoundForDifferentUser", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
createdChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "private chat",
},
},
})
require.NoError(t, err)
otherClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
otherClient := codersdk.NewExperimentalClient(otherClientRaw)
_, err = otherClient.GetChat(ctx, createdChat.ID)
requireSDKError(t, err, http.StatusNotFound)
})
// AIGatewayDisabled regression-tests that getChat is a pure DB read that
// still works when the AI Gateway is disabled and api.chatDaemon is nil.
// It builds the server without starting the test AI bridge daemon
// (unlike every other subtest here) and seeds the chat directly into the
// database, since the create-chat route itself requires the daemon.
t.Run("AIGatewayDisabled", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
values := coderdtest.DeploymentValues(t)
require.NoError(t, values.AI.BridgeConfig.Enabled.Set("false"))
opts := newChatTestOptions(t, values)
rawClient, _, api := coderdtest.NewWithAPI(t, opts)
client := codersdk.NewExperimentalClient(rawClient)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := dbgen.ChatModelConfig(t, api.Database, database.ChatModelConfig{})
seededChat := dbgen.Chat(t, api.Database, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "ai gateway disabled chat",
})
chatResult, err := client.GetChat(ctx, seededChat.ID)
require.NoError(t, err)
require.Equal(t, seededChat.ID, chatResult.ID)
require.Equal(t, firstUser.UserID, chatResult.OwnerID)
require.Equal(t, modelConfig.ID, chatResult.LastModelConfigID)
require.Equal(t, "ai gateway disabled chat", chatResult.Title)
})
t.Run("FilesHydrated", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Upload a file.
pngData := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploadResp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "hydrated.png", bytes.NewReader(pngData))
require.NoError(t, err)
// Create a chat with a text + file part.
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "check file hydration"}, {Type: codersdk.ChatInputPartTypeFile, FileID: uploadResp.ID},
},
})
require.NoError(t, err)
// GET the chat — files must be hydrated with all metadata fields.
chatResult, err := client.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Len(t, chatResult.Files, 1)
f := chatResult.Files[0]
require.Equal(t, uploadResp.ID, f.ID)
require.Equal(t, firstUser.UserID, f.OwnerID)
require.NotEqual(t, uuid.Nil, f.OrganizationID)
require.Equal(t, "image/png", f.MimeType)
require.Equal(t, "hydrated.png", f.Name)
require.NotZero(t, f.CreatedAt)
})
// ToolCreatedFilesLinked exercises the DB path that chatd uses
// when a tool (e.g. propose_plan) creates a file: InsertChatFile
// then LinkChatFiles. This is a DB-level test because driving
// the full chatd tool-call pipeline requires an LLM mock.
t.Run("ToolCreatedFilesLinked", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, store := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Create a chat via the API so all metadata is set up.
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "tool file test"},
},
})
require.NoError(t, err)
// Mimic what chatd's StoreFile closure does:
// 1. InsertChatFile
// 2. LinkChatFiles
//nolint:gocritic // Using AsChatd to mimic the chatd background worker.
chatdCtx := dbauthz.AsChatd(ctx)
fileRow, err := store.InsertChatFile(chatdCtx, database.InsertChatFileParams{
OwnerID: firstUser.UserID,
OrganizationID: firstUser.OrganizationID,
Name: "plan.md",
Mimetype: "text/markdown",
Data: []byte("# Plan"),
})
require.NoError(t, err)
rejected, err := store.LinkChatFiles(chatdCtx, database.LinkChatFilesParams{
ChatID: chat.ID,
MaxFileLinks: int32(codersdk.DefaultChatMaxAttachmentsPerChat),
FileIds: []uuid.UUID{fileRow.ID},
})
require.NoError(t, err)
require.Equal(t, int32(0), rejected, "0 rejected = all files linked")
// Verify via the API that the file appears in the chat.
chatResult, err := client.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Len(t, chatResult.Files, 1)
f := chatResult.Files[0]
require.Equal(t, fileRow.ID, f.ID)
require.Equal(t, firstUser.UserID, f.OwnerID)
require.Equal(t, firstUser.OrganizationID, f.OrganizationID)
require.Equal(t, "plan.md", f.Name)
require.Equal(t, "text/markdown", f.MimeType)
})
t.Run("GetChatEmbedsChildren", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db, api := newChatClientWithAPIAndDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
parentChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "parent for getChat",
},
},
})
require.NoError(t, err)
// The parent chat is created via the API, so the chat worker moves
// it to running. Archiving is only allowed from a terminal state,
// so wait for it to settle before archiving below.
coderdtest.WaitForChatSettled(ctx, t, api, parentChat.ID)
child := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "child for getChat",
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
// Fetching the root chat should embed its children.
result, err := client.GetChat(ctx, parentChat.ID)
require.NoError(t, err)
require.Len(t, result.Children, 1)
require.Equal(t, child.ID, result.Children[0].ID)
require.NotNil(t, result.Children[0].ParentChatID)
require.Equal(t, parentChat.ID, *result.Children[0].ParentChatID)
// Fetching a child chat should not have children.
childResult, err := client.GetChat(ctx, child.ID)
require.NoError(t, err)
require.NotNil(t, childResult.Children)
require.Empty(t, childResult.Children)
// An archived root should still embed its cascaded
// archived children (guards against the filter getting
// hardcoded to false).
err = client.UpdateChat(ctx, parentChat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)})
require.NoError(t, err)
archivedResult, err := client.GetChat(ctx, parentChat.ID)
require.NoError(t, err)
require.True(t, archivedResult.Archived, "root should be archived")
require.Len(t, archivedResult.Children, 1, "archived root should embed its archived child")
require.Equal(t, child.ID, archivedResult.Children[0].ID)
require.True(t, archivedResult.Children[0].Archived, "embedded child should be archived")
})
}
func TestGetChatUserPrompts(t *testing.T) {
t.Parallel()
insertUserMessage := func(
t *testing.T,
ctx context.Context,
db database.Store,
chatID uuid.UUID,
modelConfigID uuid.UUID,
userID uuid.UUID,
parts []codersdk.ChatMessagePart,
visibility database.ChatMessageVisibility,
deleted bool,
) database.ChatMessage {
t.Helper()
content, err := chatprompt.MarshalParts(parts)
require.NoError(t, err)
msgs, err := db.InsertChatMessages(dbauthz.AsSystemRestricted(ctx), database.InsertChatMessagesParams{
ChatID: chatID,
CreatedBy: []uuid.UUID{userID},
ModelConfigID: []uuid.UUID{modelConfigID},
Role: []database.ChatMessageRole{database.ChatMessageRoleUser},
ContentVersion: []int16{chatprompt.CurrentContentVersion},
Content: []string{string(content.RawMessage)},
Visibility: []database.ChatMessageVisibility{visibility},
InputTokens: []int64{0},
OutputTokens: []int64{0},
TotalTokens: []int64{0},
ReasoningTokens: []int64{0},
CacheCreationTokens: []int64{0},
CacheReadTokens: []int64{0},
ContextLimit: []int64{0},
Compressed: []bool{false},
RuntimeMs: []int64{0},
})
require.NoError(t, err)
require.Len(t, msgs, 1)
if deleted {
require.NoError(t, db.SoftDeleteChatMessagesAfterID(dbauthz.AsSystemRestricted(ctx), database.SoftDeleteChatMessagesAfterIDParams{
ChatID: chatID,
AfterID: msgs[0].ID - 1,
}))
}
return database.ChatMessage(msgs[0])
}
t.Run("NewestFirstFiltering", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat, err := db.InsertChat(dbauthz.AsSystemRestricted(ctx), database.InsertChatParams{
OrganizationID: user.OrganizationID,
Status: database.ChatStatusWaiting,
ClientType: database.ChatClientTypeUi,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "prompts route test",
})
require.NoError(t, err)
// Older user prompt with multiple text parts that need
// concatenation in original order.
want1 := insertUserMessage(t, ctx, db, chat.ID, modelConfig.ID, user.UserID,
[]codersdk.ChatMessagePart{
{Type: codersdk.ChatMessagePartTypeText, Text: "first "},
{Type: codersdk.ChatMessagePartTypeText, Text: "prompt"},
},
database.ChatMessageVisibilityBoth, false,
)
// User prompt with a non-text part interleaved; only text
// parts should appear in the response, joined verbatim.
want2 := insertUserMessage(t, ctx, db, chat.ID, modelConfig.ID, user.UserID,
[]codersdk.ChatMessagePart{
{Type: codersdk.ChatMessagePartTypeText, Text: "hello "},
{Type: codersdk.ChatMessagePartTypeFile, MediaType: "text/plain", Data: []byte("x")},
{Type: codersdk.ChatMessagePartTypeText, Text: "world"},
},
database.ChatMessageVisibilityBoth, false,
)
// Whitespace-only prompt; must be filtered out by the
// HAVING clause so cycling never lands on a blank entry.
insertUserMessage(t, ctx, db, chat.ID, modelConfig.ID, user.UserID,
[]codersdk.ChatMessagePart{
{Type: codersdk.ChatMessagePartTypeText, Text: " \n\t "},
},
database.ChatMessageVisibilityBoth, false,
)
// Assistant-role message with otherwise-valid content;
// the SQL filter cm.role = 'user' must exclude it from
// the response.
assistantContent, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
{Type: codersdk.ChatMessagePartTypeText, Text: "assistant reply"},
})
require.NoError(t, err)
_, err = db.InsertChatMessages(dbauthz.AsSystemRestricted(ctx), database.InsertChatMessagesParams{
ChatID: chat.ID,
CreatedBy: []uuid.UUID{user.UserID},
ModelConfigID: []uuid.UUID{modelConfig.ID},
Role: []database.ChatMessageRole{database.ChatMessageRoleAssistant},
ContentVersion: []int16{chatprompt.CurrentContentVersion},
Content: []string{string(assistantContent.RawMessage)},
Visibility: []database.ChatMessageVisibility{database.ChatMessageVisibilityBoth},
InputTokens: []int64{0},
OutputTokens: []int64{0},
TotalTokens: []int64{0},
ReasoningTokens: []int64{0},
CacheCreationTokens: []int64{0},
CacheReadTokens: []int64{0},
ContextLimit: []int64{0},
Compressed: []bool{false},
RuntimeMs: []int64{0},
})
require.NoError(t, err)
// Legacy V0 user message stored as a scalar JSON string
// (predates migration 000434). The jsonb_typeof guard in
// GetChatUserPromptsByChatID must silently exclude this row;
// without the guard, jsonb_array_elements would raise
// "cannot extract elements from a scalar" and the request
// would 500.
_, err = db.InsertChatMessages(dbauthz.AsSystemRestricted(ctx), database.InsertChatMessagesParams{
ChatID: chat.ID,
CreatedBy: []uuid.UUID{user.UserID},
ModelConfigID: []uuid.UUID{modelConfig.ID},
Role: []database.ChatMessageRole{database.ChatMessageRoleUser},
ContentVersion: []int16{0},
Content: []string{`"plain text from V0"`},
Visibility: []database.ChatMessageVisibility{database.ChatMessageVisibilityBoth},
InputTokens: []int64{0},
OutputTokens: []int64{0},
TotalTokens: []int64{0},
ReasoningTokens: []int64{0},
CacheCreationTokens: []int64{0},
CacheReadTokens: []int64{0},
ContextLimit: []int64{0},
Compressed: []bool{false},
RuntimeMs: []int64{0},
})
require.NoError(t, err)
// Soft-deleted prompt; must not appear.
insertUserMessage(t, ctx, db, chat.ID, modelConfig.ID, user.UserID,
[]codersdk.ChatMessagePart{
{Type: codersdk.ChatMessagePartTypeText, Text: "deleted prompt"},
},
database.ChatMessageVisibilityBoth, true,
)
// Model-only visibility prompt; must not appear (composer
// only shows what the user actually typed).
insertUserMessage(t, ctx, db, chat.ID, modelConfig.ID, user.UserID,
[]codersdk.ChatMessagePart{
{Type: codersdk.ChatMessagePartTypeText, Text: "model only"},
},
database.ChatMessageVisibilityModel, false,
)
// Newest user-visible prompt; should come first in the
// response.
want3 := insertUserMessage(t, ctx, db, chat.ID, modelConfig.ID, user.UserID,
[]codersdk.ChatMessagePart{
{Type: codersdk.ChatMessagePartTypeText, Text: "newest prompt"},
},
database.ChatMessageVisibilityUser, false,
)
resp, err := client.GetChatPrompts(ctx, chat.ID, nil)
require.NoError(t, err)
require.Len(t, resp.Prompts, 3, "expected exactly the three user-visible non-blank prompts")
require.Equal(t, want3.ID, resp.Prompts[0].ID)
require.Equal(t, "newest prompt", resp.Prompts[0].Text)
require.Equal(t, want2.ID, resp.Prompts[1].ID)
require.Equal(t, "hello world", resp.Prompts[1].Text)
require.Equal(t, want1.ID, resp.Prompts[2].ID)
require.Equal(t, "first prompt", resp.Prompts[2].Text)
})
t.Run("LimitClampsResults", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat, err := db.InsertChat(dbauthz.AsSystemRestricted(ctx), database.InsertChatParams{
OrganizationID: user.OrganizationID,
Status: database.ChatStatusWaiting,
ClientType: database.ChatClientTypeUi,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "prompts limit test",
})
require.NoError(t, err)
for i := range 5 {
insertUserMessage(t, ctx, db, chat.ID, modelConfig.ID, user.UserID,
[]codersdk.ChatMessagePart{
{Type: codersdk.ChatMessagePartTypeText, Text: fmt.Sprintf("prompt %d", i)},
},
database.ChatMessageVisibilityBoth, false,
)
}
resp, err := client.GetChatPrompts(ctx, chat.ID, &codersdk.ChatPromptsOptions{Limit: 2})
require.NoError(t, err)
require.Len(t, resp.Prompts, 2)
require.Equal(t, "prompt 4", resp.Prompts[0].Text)
require.Equal(t, "prompt 3", resp.Prompts[1].Text)
})
t.Run("InvalidLimitRejected", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat, err := db.InsertChat(dbauthz.AsSystemRestricted(ctx), database.InsertChatParams{
OrganizationID: user.OrganizationID,
Status: database.ChatStatusWaiting,
ClientType: database.ChatClientTypeUi,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "prompts invalid limit test",
})
require.NoError(t, err)
_, err = client.GetChatPrompts(ctx, chat.ID, &codersdk.ChatPromptsOptions{Limit: 5000})
require.Error(t, err)
var sdkErr *codersdk.Error
require.ErrorAs(t, err, &sdkErr)
require.Equal(t, http.StatusBadRequest, sdkErr.StatusCode())
})
t.Run("NotFoundForOtherUsers", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat, err := db.InsertChat(dbauthz.AsSystemRestricted(ctx), database.InsertChatParams{
OrganizationID: firstUser.OrganizationID,
Status: database.ChatStatusWaiting,
ClientType: database.ChatClientTypeUi,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "prompts cross-owner test",
})
require.NoError(t, err)
insertUserMessage(t, ctx, db, chat.ID, modelConfig.ID, firstUser.UserID,
[]codersdk.ChatMessagePart{
{Type: codersdk.ChatMessagePartTypeText, Text: "private prompt"},
},
database.ChatMessageVisibilityBoth, false,
)
memberClient, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberExp := codersdk.NewExperimentalClient(memberClient)
_, err = memberExp.GetChatPrompts(ctx, chat.ID, nil)
require.Error(t, err)
var sdkErr *codersdk.Error
require.ErrorAs(t, err, &sdkErr)
require.Equal(t, http.StatusNotFound, sdkErr.StatusCode())
})
t.Run("EmptyResultIsJSONArray", func(t *testing.T) {
t.Parallel()
// Boundary: a chat with no user-visible prompts must
// serialize to {"prompts":[]}, not {"prompts":null}, so
// the composer's cycle code can branch on len() without
// guarding against nil. We exercise both branches: a chat
// with zero messages, and a chat that has only an
// assistant message (the SQL filter excludes it).
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
emptyChat, err := db.InsertChat(dbauthz.AsSystemRestricted(ctx), database.InsertChatParams{
OrganizationID: user.OrganizationID,
Status: database.ChatStatusWaiting,
ClientType: database.ChatClientTypeUi,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "prompts empty chat test",
})
require.NoError(t, err)
resp, err := client.GetChatPrompts(ctx, emptyChat.ID, nil)
require.NoError(t, err)
require.NotNil(t, resp.Prompts, "prompts must be [] not nil")
require.Empty(t, resp.Prompts)
assistantOnlyChat, err := db.InsertChat(dbauthz.AsSystemRestricted(ctx), database.InsertChatParams{
OrganizationID: user.OrganizationID,
Status: database.ChatStatusWaiting,
ClientType: database.ChatClientTypeUi,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "prompts assistant-only chat test",
})
require.NoError(t, err)
assistantContent, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
{Type: codersdk.ChatMessagePartTypeText, Text: "assistant reply"},
})
require.NoError(t, err)
_, err = db.InsertChatMessages(dbauthz.AsSystemRestricted(ctx), database.InsertChatMessagesParams{
ChatID: assistantOnlyChat.ID,
CreatedBy: []uuid.UUID{user.UserID},
ModelConfigID: []uuid.UUID{modelConfig.ID},
Role: []database.ChatMessageRole{database.ChatMessageRoleAssistant},
ContentVersion: []int16{chatprompt.CurrentContentVersion},
Content: []string{string(assistantContent.RawMessage)},
Visibility: []database.ChatMessageVisibility{database.ChatMessageVisibilityBoth},
InputTokens: []int64{0},
OutputTokens: []int64{0},
TotalTokens: []int64{0},
ReasoningTokens: []int64{0},
CacheCreationTokens: []int64{0},
CacheReadTokens: []int64{0},
ContextLimit: []int64{0},
Compressed: []bool{false},
RuntimeMs: []int64{0},
})
require.NoError(t, err)
resp, err = client.GetChatPrompts(ctx, assistantOnlyChat.ID, nil)
require.NoError(t, err)
require.NotNil(t, resp.Prompts, "prompts must be [] not nil")
require.Empty(t, resp.Prompts)
})
}
func TestGetChatAttachments(t *testing.T) {
t.Parallel()
insertMessage := func(
t *testing.T,
ctx context.Context,
db database.Store,
chat database.Chat,
role database.ChatMessageRole,
parts []codersdk.ChatMessagePart,
visibility database.ChatMessageVisibility,
deleted bool,
) database.ChatMessage {
t.Helper()
content, err := chatprompt.MarshalParts(parts)
require.NoError(t, err)
msgs, err := db.InsertChatMessages(dbauthz.AsSystemRestricted(ctx), database.InsertChatMessagesParams{
ChatID: chat.ID,
CreatedBy: []uuid.UUID{chat.OwnerID},
ModelConfigID: []uuid.UUID{chat.LastModelConfigID},
Role: []database.ChatMessageRole{role},
ContentVersion: []int16{chatprompt.CurrentContentVersion},
Content: []string{string(content.RawMessage)},
Visibility: []database.ChatMessageVisibility{visibility},
InputTokens: []int64{0},
OutputTokens: []int64{0},
TotalTokens: []int64{0},
ReasoningTokens: []int64{0},
CacheCreationTokens: []int64{0},
CacheReadTokens: []int64{0},
ContextLimit: []int64{0},
Compressed: []bool{false},
RuntimeMs: []int64{0},
})
require.NoError(t, err)
require.Len(t, msgs, 1)
if deleted {
require.NoError(t, db.SoftDeleteChatMessagesAfterID(dbauthz.AsSystemRestricted(ctx), database.SoftDeleteChatMessagesAfterIDParams{
ChatID: chat.ID,
AfterID: msgs[0].ID - 1,
}))
}
return database.ChatMessage(msgs[0])
}
insertChat := func(t *testing.T, ctx context.Context, db database.Store, user codersdk.CreateFirstUserResponse, modelConfigID uuid.UUID) database.Chat {
t.Helper()
chat, err := db.InsertChat(dbauthz.AsSystemRestricted(ctx), database.InsertChatParams{
OrganizationID: user.OrganizationID,
Status: database.ChatStatusWaiting,
ClientType: database.ChatClientTypeUi,
OwnerID: user.UserID,
LastModelConfigID: modelConfigID,
Title: "attachments route test",
})
require.NoError(t, err)
return chat
}
t.Run("NewestFirstFiltering", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := insertChat(t, ctx, db, user, modelConfig.ID)
fileA := codersdk.ChatMessageFile(uuid.New(), "image/png", "a.png")
fileB := codersdk.ChatMessageFile(uuid.New(), "text/plain", "b.txt")
fileC := codersdk.ChatMessageFile(uuid.New(), "text/plain", "c.txt")
fileD := codersdk.ChatMessageFile(uuid.New(), "image/png", "d.png")
text := codersdk.ChatMessagePart{Type: codersdk.ChatMessagePartTypeText, Text: "hello"}
userUpload := insertMessage(t, ctx, db, chat, database.ChatMessageRoleUser,
[]codersdk.ChatMessagePart{text, fileA},
database.ChatMessageVisibilityBoth, false)
agentFiles := insertMessage(t, ctx, db, chat, database.ChatMessageRoleAssistant,
[]codersdk.ChatMessagePart{fileB, text, fileC},
database.ChatMessageVisibilityBoth, false)
// Each of these hides its file part from the user, so none may
// appear in the response.
insertMessage(t, ctx, db, chat, database.ChatMessageRoleUser,
[]codersdk.ChatMessagePart{codersdk.ChatMessageFile(uuid.New(), "text/plain", "deleted.txt")},
database.ChatMessageVisibilityBoth, true)
insertMessage(t, ctx, db, chat, database.ChatMessageRoleUser,
[]codersdk.ChatMessagePart{codersdk.ChatMessageFile(uuid.New(), "text/plain", "model.txt")},
database.ChatMessageVisibilityModel, false)
insertMessage(t, ctx, db, chat, database.ChatMessageRoleTool,
[]codersdk.ChatMessagePart{codersdk.ChatMessageFile(uuid.New(), "image/png", "tool.png")},
database.ChatMessageVisibilityBoth, false)
insertMessage(t, ctx, db, chat, database.ChatMessageRoleUser,
[]codersdk.ChatMessagePart{text},
database.ChatMessageVisibilityBoth, false)
// The hook-context part is stripped from client responses, so the
// file part's index must shift to match the messages endpoint.
hookPrompt := insertMessage(t, ctx, db, chat, database.ChatMessageRoleUser,
[]codersdk.ChatMessagePart{
{Type: codersdk.ChatMessagePartTypeHookContext, Text: "model only"},
fileD,
},
database.ChatMessageVisibilityUser, false)
// An inline part keeps its bytes because it has no stored file.
inlinePaste := insertMessage(t, ctx, db, chat, database.ChatMessageRoleUser,
[]codersdk.ChatMessagePart{
{Type: codersdk.ChatMessagePartTypeFile, MediaType: "text/plain", Data: []byte("pasted")},
},
database.ChatMessageVisibilityBoth, false)
resp, err := client.GetChatAttachments(ctx, chat.ID, nil)
require.NoError(t, err)
type attachment struct {
MessageID int64
PartIndex int
Role codersdk.ChatAttachmentRole
FileID uuid.UUID
}
got := make([]attachment, 0, len(resp.Attachments))
for _, a := range resp.Attachments {
got = append(got, attachment{a.MessageID, a.PartIndex, a.Role, a.File.FileID.UUID})
}
require.Equal(t, []attachment{
{inlinePaste.ID, 0, codersdk.ChatAttachmentRoleUser, uuid.Nil},
{hookPrompt.ID, 0, codersdk.ChatAttachmentRoleUser, fileD.FileID.UUID},
{agentFiles.ID, 2, codersdk.ChatAttachmentRoleAssistant, fileC.FileID.UUID},
{agentFiles.ID, 0, codersdk.ChatAttachmentRoleAssistant, fileB.FileID.UUID},
{userUpload.ID, 1, codersdk.ChatAttachmentRoleUser, fileA.FileID.UUID},
}, got)
messages, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
contentByID := make(map[int64][]codersdk.ChatMessagePart, len(messages.Messages))
for _, m := range messages.Messages {
contentByID[m.ID] = m.Content
}
for _, a := range resp.Attachments {
content := contentByID[a.MessageID]
require.Less(t, a.PartIndex, len(content))
part := content[a.PartIndex]
require.Equal(t, codersdk.ChatMessagePartTypeFile, part.Type)
require.Equal(t, codersdk.ChatAttachmentFile{
Type: codersdk.ChatAttachmentFileTypeFile,
MediaType: part.MediaType,
Name: part.Name,
Data: part.Data,
FileID: part.FileID,
}, a.File, "attachment must carry the messages endpoint part's file fields")
}
before, err := client.GetChatAttachments(ctx, chat.ID, &codersdk.ChatAttachmentsOptions{BeforeID: agentFiles.ID})
require.NoError(t, err)
require.Len(t, before.Attachments, 1)
require.Equal(t, userUpload.ID, before.Attachments[0].MessageID)
none, err := client.GetChatAttachments(ctx, chat.ID, &codersdk.ChatAttachmentsOptions{BeforeID: userUpload.ID})
require.NoError(t, err)
require.NotNil(t, none.Attachments, "attachments must be [] not nil")
require.Empty(t, none.Attachments)
})
t.Run("InlineFileWireFormat", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := insertChat(t, ctx, db, user, modelConfig.ID)
stored := codersdk.ChatMessageFile(uuid.New(), "text/plain", "stored.txt")
insertMessage(t, ctx, db, chat, database.ChatMessageRoleUser,
[]codersdk.ChatMessagePart{
stored,
{Type: codersdk.ChatMessagePartTypeFile, MediaType: "text/plain", Data: []byte("pasted")},
},
database.ChatMessageVisibilityBoth, false)
res, err := client.Request(ctx, http.MethodGet,
fmt.Sprintf("/api/v2/chats/%s/attachments", chat.ID), nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
var body struct {
Attachments []struct {
PartIndex int `json:"part_index"`
File map[string]json.RawMessage `json:"file"`
} `json:"attachments"`
}
require.NoError(t, json.NewDecoder(res.Body).Decode(&body))
files := make(map[int]map[string]json.RawMessage, len(body.Attachments))
for _, a := range body.Attachments {
files[a.PartIndex] = a.File
}
require.Len(t, files, 2)
require.JSONEq(t, fmt.Sprintf("%q", stored.FileID.UUID), string(files[0]["file_id"]))
require.NotContains(t, files[1], "file_id", "an inline file must omit file_id, not send null")
var data string
require.NoError(t, json.Unmarshal(files[1]["data"], &data), "data must be a base64 string")
require.Equal(t, base64.StdEncoding.EncodeToString([]byte("pasted")), data)
})
t.Run("InvalidBeforeIDRejected", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := insertChat(t, ctx, db, user, modelConfig.ID)
res, err := client.Request(ctx, http.MethodGet,
fmt.Sprintf("/api/v2/chats/%s/attachments?before_id=-1", chat.ID), nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusBadRequest, res.StatusCode)
})
t.Run("NotFoundForOtherUsers", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := insertChat(t, ctx, db, firstUser, modelConfig.ID)
insertMessage(t, ctx, db, chat, database.ChatMessageRoleUser,
[]codersdk.ChatMessagePart{codersdk.ChatMessageFile(uuid.New(), "text/plain", "private.txt")},
database.ChatMessageVisibilityBoth, false)
memberClient, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberExp := codersdk.NewExperimentalClient(memberClient)
_, err := memberExp.GetChatAttachments(ctx, chat.ID, nil)
require.Error(t, err)
var sdkErr *codersdk.Error
require.ErrorAs(t, err, &sdkErr)
require.Equal(t, http.StatusNotFound, sdkErr.StatusCode())
})
}
func TestPatchChat(t *testing.T) {
t.Parallel()
createChat := func(ctx context.Context, t *testing.T, client *codersdk.ExperimentalClient, orgID uuid.UUID, text string) codersdk.Chat {
t.Helper()
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: orgID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: text,
},
},
})
require.NoError(t, err)
return chat
}
getChat := func(ctx context.Context, t *testing.T, client *codersdk.ExperimentalClient, chatID uuid.UUID) codersdk.Chat {
t.Helper()
chat, err := client.GetChat(ctx, chatID)
require.NoError(t, err)
return chat
}
createStoredChat := func(
ctx context.Context,
t *testing.T,
db database.Store,
ownerID uuid.UUID,
orgID uuid.UUID,
modelConfigID uuid.UUID,
title string,
) codersdk.Chat {
t.Helper()
dbChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: orgID,
OwnerID: ownerID,
LastModelConfigID: modelConfigID,
Title: title,
})
return db2sdk.Chat(dbChat, nil, nil)
}
t.Run("PlanMode", func(t *testing.T) {
t.Parallel()
t.Run("SetToPlan", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
client := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChat(ctx, t, client, firstUser.OrganizationID, "set plan mode")
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
PlanMode: ptr.Ref(codersdk.ChatPlanModePlan),
})
require.NoError(t, err)
updated := getChat(ctx, t, client, chat.ID)
require.Equal(t, codersdk.ChatPlanModePlan, updated.PlanMode)
require.True(t, mAudit.Contains(t, database.AuditLog{
Action: database.AuditActionWrite,
ResourceType: database.ResourceTypeChat,
ResourceID: chat.ID,
UserID: firstUser.UserID,
}))
})
t.Run("Clear", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
client := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChat(ctx, t, client, firstUser.OrganizationID, "clear plan mode")
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
PlanMode: ptr.Ref(codersdk.ChatPlanModePlan),
})
require.NoError(t, err)
err = client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
PlanMode: ptr.Ref(codersdk.ChatPlanMode("")),
})
require.NoError(t, err)
updated := getChat(ctx, t, client, chat.ID)
require.Empty(t, updated.PlanMode)
require.True(t, mAudit.Contains(t, database.AuditLog{
Action: database.AuditActionWrite,
ResourceType: database.ResourceTypeChat,
ResourceID: chat.ID,
UserID: firstUser.UserID,
}))
})
t.Run("RejectsInvalidValue", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
client := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChat(ctx, t, client, firstUser.OrganizationID, "invalid plan mode")
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
PlanMode: ptr.Ref(codersdk.ChatPlanMode("invalid")),
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid plan_mode value.", sdkErr.Message)
require.True(t, mAudit.Contains(t, database.AuditLog{
Action: database.AuditActionWrite,
ResourceType: database.ResourceTypeChat,
ResourceID: chat.ID,
UserID: firstUser.UserID,
}))
})
})
t.Run("WorkspaceBinding", func(t *testing.T) {
t.Parallel()
t.Run("BindExistingExternalWorkspace", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
client, db := newChatClientWithDatabase(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
workspaceBuild := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
}).Seed(database.WorkspaceBuild{
HasExternalAgent: sql.NullBool{Bool: true, Valid: true},
}).WithAgent().Do()
chat := createStoredChat(
ctx,
t,
db,
firstUser.UserID,
firstUser.OrganizationID,
modelConfig.ID,
"bind workspace",
)
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
WorkspaceID: &workspaceBuild.Workspace.ID,
})
require.NoError(t, err)
updated := getChat(ctx, t, client, chat.ID)
require.NotNil(t, updated.WorkspaceID)
require.Equal(t, workspaceBuild.Workspace.ID, *updated.WorkspaceID)
require.True(t, mAudit.Contains(t, database.AuditLog{
Action: database.AuditActionWrite,
ResourceType: database.ResourceTypeChat,
ResourceID: chat.ID,
UserID: firstUser.UserID,
}))
})
t.Run("WorkspaceNotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
client, db := newChatClientWithDatabase(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := createStoredChat(
ctx,
t,
db,
firstUser.UserID,
firstUser.OrganizationID,
modelConfig.ID,
"missing workspace",
)
workspaceID := uuid.New()
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
WorkspaceID: &workspaceID,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Workspace not found or you do not have access to this resource", sdkErr.Message)
require.True(t, mAudit.Contains(t, database.AuditLog{
Action: database.AuditActionWrite,
ResourceType: database.ResourceTypeChat,
ResourceID: chat.ID,
UserID: firstUser.UserID,
}))
})
t.Run("RejectsCrossOrgWorkspaceBinding", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
client, db := newChatClientWithDatabase(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
secondOrg := dbgen.Organization(t, db, database.Organization{})
dbgen.OrganizationMember(t, db, database.OrganizationMember{
OrganizationID: secondOrg.ID,
UserID: firstUser.UserID,
})
workspaceBuild := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: secondOrg.ID,
OwnerID: firstUser.UserID,
}).WithAgent().Do()
chat := createStoredChat(
ctx,
t,
db,
firstUser.UserID,
firstUser.OrganizationID,
modelConfig.ID,
"cross org workspace binding",
)
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
WorkspaceID: &workspaceBuild.Workspace.ID,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Workspace does not belong to this chat's organization.", sdkErr.Message)
require.True(t, mAudit.Contains(t, database.AuditLog{
Action: database.AuditActionWrite,
ResourceType: database.ResourceTypeChat,
ResourceID: chat.ID,
UserID: firstUser.UserID,
}))
})
t.Run("ClearWorkspaceBinding", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
client, db := newChatClientWithDatabase(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
workspaceBuild := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
}).WithAgent().Do()
chat := createStoredChat(
ctx,
t,
db,
firstUser.UserID,
firstUser.OrganizationID,
modelConfig.ID,
"clear workspace binding",
)
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
WorkspaceID: &workspaceBuild.Workspace.ID,
})
require.NoError(t, err)
workspaceID := uuid.Nil
err = client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
WorkspaceID: &workspaceID,
})
require.NoError(t, err)
updated := getChat(ctx, t, client, chat.ID)
require.Nil(t, updated.WorkspaceID)
require.Nil(t, updated.BuildID)
require.Nil(t, updated.AgentID)
require.True(t, mAudit.Contains(t, database.AuditLog{
Action: database.AuditActionWrite,
ResourceType: database.ResourceTypeChat,
ResourceID: chat.ID,
UserID: firstUser.UserID,
}))
})
t.Run("NonOwnerForbidden", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
_, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberWorkspace := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: firstUser.OrganizationID,
OwnerID: member.ID,
}).WithAgent().Do()
// The deployment owner can SSH into its own workspace, so only
// the ownership check can stop this rebind.
ownerWorkspace := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
}).WithAgent().Do()
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: member.ID,
LastModelConfigID: modelConfig.ID,
Title: "member chat",
WorkspaceID: uuid.NullUUID{UUID: memberWorkspace.Workspace.ID, Valid: true},
})
for _, workspaceID := range []uuid.UUID{ownerWorkspace.Workspace.ID, uuid.Nil} {
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Title: ptr.Ref("renamed by admin"),
WorkspaceID: &workspaceID,
})
sdkErr := requireSDKError(t, err, http.StatusForbidden)
require.Equal(t, "Only the chat owner can change its workspace.", sdkErr.Message)
persisted := getChat(ctx, t, client, chat.ID)
require.Equal(t, "member chat", persisted.Title)
require.NotNil(t, persisted.WorkspaceID)
require.Equal(t, memberWorkspace.Workspace.ID, *persisted.WorkspaceID)
}
})
})
t.Run("Title", func(t *testing.T) {
t.Parallel()
t.Run("Rename", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, api := newChatClientWithAPI(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChat(ctx, t, client, firstUser.OrganizationID, "original title")
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Title: ptr.Ref("renamed title"),
})
require.NoError(t, err)
updated := getChat(ctx, t, client, chat.ID)
require.Equal(t, "renamed title", updated.Title)
})
t.Run("TrimsWhitespace", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, api := newChatClientWithAPI(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChat(ctx, t, client, firstUser.OrganizationID, "before trim")
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Title: ptr.Ref(" padded title "),
})
require.NoError(t, err)
updated := getChat(ctx, t, client, chat.ID)
require.Equal(t, "padded title", updated.Title)
})
t.Run("RejectsEmpty", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChat(ctx, t, client, firstUser.OrganizationID, "keep original")
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Title: ptr.Ref(" "),
})
requireSDKError(t, err, http.StatusBadRequest)
updated := getChat(ctx, t, client, chat.ID)
require.Equal(t, chat.Title, updated.Title)
})
t.Run("RejectedRequestLeavesTitleUnchanged", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := createStoredChat(ctx, t, db, firstUser.UserID, firstUser.OrganizationID, modelConfig.ID, "stored title")
require.Equal(t, codersdk.ChatTitleSourceFallback, chat.TitleSource)
invalid := []struct {
field string
req codersdk.UpdateChatRequest
}{
{"labels", codersdk.UpdateChatRequest{Labels: &map[string]string{"": "bad"}}},
{"archived", codersdk.UpdateChatRequest{Archived: new(false)}},
{"pin_order", codersdk.UpdateChatRequest{PinOrder: new(int32(-1))}},
{"workspace_id", codersdk.UpdateChatRequest{WorkspaceID: new(uuid.New())}},
{"plan_mode", codersdk.UpdateChatRequest{PlanMode: new(codersdk.ChatPlanMode("invalid"))}},
}
for _, tc := range invalid {
for _, title := range []string{chat.Title, "new title"} {
req := tc.req
req.Title = &title
err := client.UpdateChat(ctx, chat.ID, req)
requireSDKError(t, err, http.StatusBadRequest)
stored := getChat(ctx, t, client, chat.ID)
require.Equal(t, chat.Title, stored.Title, "invalid %s, title %q", tc.field, title)
require.Equal(t, chat.TitleSource, stored.TitleSource, "invalid %s, title %q", tc.field, title)
require.True(t, chat.TitleUpdatedAt.Equal(stored.TitleUpdatedAt), "invalid %s, title %q", tc.field, title)
}
}
})
t.Run("LengthBoundaries", func(t *testing.T) {
t.Parallel()
cases := []struct {
name string
title string
expectOK bool
storedAs string
}{
{
name: "ExactlyMaxASCII",
title: strings.Repeat("a", 200),
expectOK: true,
storedAs: strings.Repeat("a", 200),
},
{
name: "OneOverMaxASCII",
title: strings.Repeat("a", 201),
expectOK: false,
},
{
name: "ExactlyMaxMultiByte",
title: strings.Repeat("é", 200),
expectOK: true,
storedAs: strings.Repeat("é", 200),
},
{
name: "OneOverMaxMultiByte",
title: strings.Repeat("é", 201),
expectOK: false,
},
{
name: "TrimsDownToMax",
title: " " + strings.Repeat("a", 200) + " ",
expectOK: true,
storedAs: strings.Repeat("a", 200),
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, api := newChatClientWithAPI(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChat(ctx, t, client, firstUser.OrganizationID, "boundary baseline")
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Title: ptr.Ref(tc.title),
})
updated := getChat(ctx, t, client, chat.ID)
if tc.expectOK {
require.NoError(t, err)
require.Equal(t, tc.storedAs, updated.Title)
} else {
requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, chat.Title, updated.Title)
}
})
}
})
t.Run("RecordsUserSourceWithoutChangingUpdatedAt", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
db, ps, sqlDB := dbtestutil.NewDBWithSQLDB(t)
clientRaw, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
DeploymentValues: coderdtest.DeploymentValues(t),
Database: db,
Pubsub: ps,
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(clientRaw)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChat(ctx, t, client, firstUser.OrganizationID, "steady title")
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
past := time.Now().UTC().Add(-2 * time.Hour).Truncate(time.Second)
_, err := sqlDB.ExecContext(ctx,
"UPDATE chats SET title = $1, title_source = 'fallback', updated_at = $2 WHERE id = $3",
"steady title", past, chat.ID,
)
require.NoError(t, err)
err = client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Title: new("steady title"),
})
require.NoError(t, err)
updated := getChat(ctx, t, client, chat.ID)
require.Equal(t, "steady title", updated.Title)
require.Equal(t, codersdk.ChatTitleSourceUser, updated.TitleSource)
require.WithinDuration(t, past, updated.UpdatedAt, time.Second)
err = client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Title: new("renamed in place"),
})
require.NoError(t, err)
renamed := getChat(ctx, t, client, chat.ID)
require.Equal(t, "renamed in place", renamed.Title)
require.Equal(t, codersdk.ChatTitleSourceUser, renamed.TitleSource)
require.True(t, renamed.TitleUpdatedAt.After(updated.TitleUpdatedAt))
require.WithinDuration(t, past, renamed.UpdatedAt, time.Second)
})
t.Run("PublishesWatchEvent", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, api := newChatClientWithAPI(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChat(ctx, t, client, firstUser.OrganizationID, "announce me")
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
conn, err := client.Dial(ctx, "/api/v2/chats/watch", nil)
require.NoError(t, err)
defer conn.Close(websocket.StatusNormalClosure, "done")
go func() {
_ = client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Title: ptr.Ref("announced name"),
})
}()
var received codersdk.ChatWatchEvent
for {
if err := wsjson.Read(ctx, conn, &received); err != nil {
break
}
if received.Kind == codersdk.ChatWatchEventKindTitleChange &&
received.Chat.ID == chat.ID {
require.Equal(t, "announced name", received.Chat.Title)
return
}
}
t.Fatalf("did not observe title_change event for chat %s", chat.ID)
})
})
}
func TestArchiveChat(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
client, api := newChatClientWithAPI(t, func(o *coderdtest.Options) {
o.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chatToArchive, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "archive me",
},
},
})
require.NoError(t, err)
chatToKeep, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "keep me",
},
},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, chatToArchive.ID)
coderdtest.WaitForChatSettled(ctx, t, api, chatToKeep.ID)
chatsBeforeArchive, err := client.ListChats(ctx, nil)
require.NoError(t, err)
require.Len(t, chatsBeforeArchive, 2)
err = client.UpdateChat(ctx, chatToArchive.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)})
require.NoError(t, err)
// Default (no filter) returns only non-archived chats.
allChats, err := client.ListChats(ctx, nil)
require.NoError(t, err)
require.Len(t, allChats, 1)
require.Equal(t, chatToKeep.ID, allChats[0].ID)
// archived:false returns only non-archived chats.
activeChats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: "archived:false",
})
require.NoError(t, err)
require.Len(t, activeChats, 1)
require.Equal(t, chatToKeep.ID, activeChats[0].ID)
require.False(t, activeChats[0].Archived)
// archived:true returns only archived chats.
archivedChats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: "archived:true",
})
require.NoError(t, err)
require.Len(t, archivedChats, 1)
require.Equal(t, chatToArchive.ID, archivedChats[0].ID)
require.True(t, archivedChats[0].Archived)
require.True(t, mAudit.Contains(t, database.AuditLog{
Action: database.AuditActionWrite,
ResourceType: database.ResourceTypeChat,
ResourceID: chatToArchive.ID,
ResourceTarget: chatToArchive.ID.String()[:8],
UserID: firstUser.UserID,
}))
})
t.Run("NotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
err := client.UpdateChat(ctx, uuid.New(), codersdk.UpdateChatRequest{Archived: ptr.Ref(true)})
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("ArchivesChildren", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db, api := newChatClientWithAPIAndDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Create a parent chat via the API.
parentChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "parent chat",
},
},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, parentChat.ID)
// Insert child chats directly via the database.
child1 := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "child 1",
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
child2 := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "child 2",
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
// Archive the parent via the API.
err = client.UpdateChat(ctx, parentChat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)})
require.NoError(t, err)
// archived:false should exclude the entire archived family.
activeChats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: "archived:false",
})
require.NoError(t, err)
for _, c := range activeChats {
require.NotEqual(t, parentChat.ID, c.ID, "parent should not appear")
require.NotEqual(t, child1.ID, c.ID, "child1 should not appear")
require.NotEqual(t, child2.ID, c.ID, "child2 should not appear")
}
// Verify children are archived directly in the DB.
dbChild1, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), child1.ID)
require.NoError(t, err)
require.True(t, dbChild1.Archived, "child1 should be archived")
dbChild2, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), child2.ID)
require.NoError(t, err)
require.True(t, dbChild2.Archived, "child2 should be archived")
// archived:true should return the parent with both
// cascaded children embedded.
archivedChats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: "archived:true",
})
require.NoError(t, err)
var foundParent *codersdk.Chat
for _, chat := range archivedChats {
if chat.ID == parentChat.ID {
foundParent = &chat
break
}
}
require.NotNil(t, foundParent, "parent should appear in archived list")
require.True(t, foundParent.Archived, "parent should be archived")
require.Len(t, foundParent.Children, 2, "both archived children should be embedded under the archived parent")
childIDs := map[uuid.UUID]bool{}
for _, child := range foundParent.Children {
require.True(t, child.Archived, "embedded child should be archived")
childIDs[child.ID] = true
}
require.True(t, childIDs[child1.ID], "child1 should be embedded under archived parent")
require.True(t, childIDs[child2.ID], "child2 should be embedded under archived parent")
})
t.Run("AllowsChildChatArchiveIndividually", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db, api := newChatClientWithAPIAndDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Create a parent chat via the API.
parentChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "parent",
},
},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, parentChat.ID)
// Insert a child chat directly via the database.
child := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "child",
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
// Archive state changes must target the root chat and cascade.
// Child archive attempts are rejected to preserve the family invariant.
err = client.UpdateChat(ctx, child.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)})
requireSDKError(t, err, http.StatusBadRequest)
dbChild, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), child.ID)
require.NoError(t, err)
require.False(t, dbChild.Archived, "child should remain active")
dbParent, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), parentChat.ID)
require.NoError(t, err)
require.False(t, dbParent.Archived, "parent should stay active")
})
}
func TestUnarchiveChat(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, api := newChatClientWithAPI(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "archive then unarchive me",
},
},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
// Archive the chat first.
err = client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)})
require.NoError(t, err)
// Verify it's archived.
archivedChats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: "archived:true",
})
require.NoError(t, err)
require.Len(t, archivedChats, 1)
require.True(t, archivedChats[0].Archived)
// Unarchive the chat.
err = client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(false)})
require.NoError(t, err)
// Verify it's no longer archived.
activeChats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: "archived:false",
})
require.NoError(t, err)
require.Len(t, activeChats, 1)
require.Equal(t, chat.ID, activeChats[0].ID)
require.False(t, activeChats[0].Archived)
// No archived chats remain.
archivedChats, err = client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: "archived:true",
})
require.NoError(t, err)
require.Empty(t, archivedChats)
})
t.Run("UnarchivesChildren", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db, api := newChatClientWithAPIAndDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
parentChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "parent chat",
},
},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, parentChat.ID)
child1 := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "child 1",
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
child2 := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "child 2",
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
err = client.UpdateChat(ctx, parentChat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)})
require.NoError(t, err)
err = client.UpdateChat(ctx, parentChat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(false)})
require.NoError(t, err)
activeChats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: "archived:false",
})
require.NoError(t, err)
// Children no longer appear as top-level entries.
// They are embedded inside the parent's Children field.
var foundParent *codersdk.Chat
for _, chat := range activeChats {
require.NotEqual(t, child1.ID, chat.ID, "child1 should not appear at top level")
require.NotEqual(t, child2.ID, chat.ID, "child2 should not appear at top level")
if chat.ID == parentChat.ID {
foundParent = &chat
}
}
require.NotNil(t, foundParent, "parent should be listed as active")
require.False(t, foundParent.Archived)
// Verify children are embedded and unarchived.
require.Len(t, foundParent.Children, 2)
childIDs := map[uuid.UUID]bool{}
for _, child := range foundParent.Children {
require.False(t, child.Archived)
childIDs[child.ID] = true
}
require.True(t, childIDs[child1.ID], "child1 should be embedded")
require.True(t, childIDs[child2.ID], "child2 should be embedded")
archivedChats, err := client.ListChats(ctx, &codersdk.ListChatsOptions{
Query: "archived:true",
})
require.NoError(t, err)
for _, chat := range archivedChats {
require.NotEqual(t, parentChat.ID, chat.ID, "parent should not remain archived")
}
dbParent, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), parentChat.ID)
require.NoError(t, err)
require.False(t, dbParent.Archived, "parent should be unarchived")
dbChild1, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), child1.ID)
require.NoError(t, err)
require.False(t, dbChild1.Archived, "child1 should be unarchived")
dbChild2, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), child2.ID)
require.NoError(t, err)
require.False(t, dbChild2.Archived, "child2 should be unarchived")
})
t.Run("NotArchived", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, api := newChatClientWithAPI(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "not archived",
},
},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
// Trying to unarchive a non-archived chat should fail.
err = client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(false)})
requireSDKError(t, err, http.StatusBadRequest)
})
t.Run("RejectsChildChatWhenParentArchived", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db, api := newChatClientWithAPIAndDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Create a parent chat via the API.
parentChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "parent",
},
},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, parentChat.ID)
// Insert a child directly via the database, then archive the
// parent so the whole family is archived (cascade).
child := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "child",
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
err = client.UpdateChat(ctx, parentChat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)})
require.NoError(t, err)
// Unarchiving the child while the parent stays archived
// must be rejected. Otherwise the child becomes a ghost
// (active list excludes the parent, archived list's child
// query filters archived=true so the now-unarchived child
// is also excluded).
err = client.UpdateChat(ctx, child.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(false)})
requireSDKError(t, err, http.StatusBadRequest)
dbChild, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), child.ID)
require.NoError(t, err)
require.True(t, dbChild.Archived, "child should still be archived")
})
t.Run("AllowsChildChatWhenParentNotArchived", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db, api := newChatClientWithAPIAndDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
parentChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "parent",
},
},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, parentChat.ID)
// Simulate legacy lone-archived child (from before the
// child-archive gate existed) by inserting it directly
// with archived=true while the parent is not archived.
child := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "legacy child",
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
_, err = db.ArchiveChatByID(dbauthz.AsSystemRestricted(ctx), child.ID)
require.NoError(t, err)
// Archive state changes must target the root chat, even when
// the child is a legacy lone-archived row.
err = client.UpdateChat(ctx, child.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(false)})
requireSDKError(t, err, http.StatusBadRequest)
dbChild, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), child.ID)
require.NoError(t, err)
require.True(t, dbChild.Archived, "child should remain archived")
})
t.Run("NotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
err := client.UpdateChat(ctx, uuid.New(), codersdk.UpdateChatRequest{Archived: ptr.Ref(false)})
requireSDKError(t, err, http.StatusNotFound)
})
}
func TestChatPinOrder(t *testing.T) {
t.Parallel()
createChat := func(ctx context.Context, t *testing.T, client *codersdk.ExperimentalClient, orgID uuid.UUID, title string) codersdk.Chat {
t.Helper()
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: orgID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: title,
},
},
})
require.NoError(t, err)
return chat
}
getChat := func(ctx context.Context, t *testing.T, client *codersdk.ExperimentalClient, chatID uuid.UUID) codersdk.Chat {
t.Helper()
chat, err := client.GetChat(ctx, chatID)
require.NoError(t, err)
return chat
}
t.Run("PinReorderAndUnpin", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
first := createChat(ctx, t, client, firstUser.OrganizationID, "first pinned chat")
second := createChat(ctx, t, client, firstUser.OrganizationID, "second pinned chat")
third := createChat(ctx, t, client, firstUser.OrganizationID, "third pinned chat")
err := client.UpdateChat(ctx, first.ID, codersdk.UpdateChatRequest{PinOrder: ptr.Ref(int32(1))})
require.NoError(t, err)
err = client.UpdateChat(ctx, second.ID, codersdk.UpdateChatRequest{PinOrder: ptr.Ref(int32(1))})
require.NoError(t, err)
err = client.UpdateChat(ctx, third.ID, codersdk.UpdateChatRequest{PinOrder: ptr.Ref(int32(1))})
require.NoError(t, err)
first = getChat(ctx, t, client, first.ID)
second = getChat(ctx, t, client, second.ID)
third = getChat(ctx, t, client, third.ID)
require.EqualValues(t, 1, first.PinOrder)
require.EqualValues(t, 2, second.PinOrder)
require.EqualValues(t, 3, third.PinOrder)
err = client.UpdateChat(ctx, third.ID, codersdk.UpdateChatRequest{PinOrder: ptr.Ref(int32(1))})
require.NoError(t, err)
first = getChat(ctx, t, client, first.ID)
second = getChat(ctx, t, client, second.ID)
third = getChat(ctx, t, client, third.ID)
require.EqualValues(t, 2, first.PinOrder)
require.EqualValues(t, 3, second.PinOrder)
require.EqualValues(t, 1, third.PinOrder)
err = client.UpdateChat(ctx, first.ID, codersdk.UpdateChatRequest{PinOrder: ptr.Ref(int32(0))})
require.NoError(t, err)
first = getChat(ctx, t, client, first.ID)
second = getChat(ctx, t, client, second.ID)
third = getChat(ctx, t, client, third.ID)
require.Zero(t, first.PinOrder)
require.EqualValues(t, 2, second.PinOrder)
require.EqualValues(t, 1, third.PinOrder)
})
t.Run("ArchiveClearsPinOrder", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, api := newChatClientWithAPI(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
first := createChat(ctx, t, client, firstUser.OrganizationID, "pinned then archived")
second := createChat(ctx, t, client, firstUser.OrganizationID, "stays pinned")
coderdtest.WaitForChatSettled(ctx, t, api, first.ID)
coderdtest.WaitForChatSettled(ctx, t, api, second.ID)
// Pin both.
err := client.UpdateChat(ctx, first.ID, codersdk.UpdateChatRequest{PinOrder: ptr.Ref(int32(1))})
require.NoError(t, err)
err = client.UpdateChat(ctx, second.ID, codersdk.UpdateChatRequest{PinOrder: ptr.Ref(int32(1))})
require.NoError(t, err)
// Archive the first — pin_order should be cleared.
err = client.UpdateChat(ctx, first.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)})
require.NoError(t, err)
first = getChat(ctx, t, client, first.ID)
second = getChat(ctx, t, client, second.ID)
require.Zero(t, first.PinOrder, "archived chat should have pin_order 0")
require.True(t, first.Archived)
// The remaining pin keeps its original position. The next
// pin/unpin/reorder operation compacts via ROW_NUMBER().
require.EqualValues(t, 2, second.PinOrder, "remaining pin keeps original position")
})
t.Run("RejectsNegative", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChat(ctx, t, client, firstUser.OrganizationID, "negative pin order")
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{PinOrder: ptr.Ref(int32(-1))})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Pin order must be non-negative.", sdkErr.Message)
chat = getChat(ctx, t, client, chat.ID)
require.Zero(t, chat.PinOrder)
})
t.Run("RejectsChildChat", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
parentChat := createChat(ctx, t, client, firstUser.OrganizationID, "parent chat")
child := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "child chat",
Status: database.ChatStatusWaiting,
ParentChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: parentChat.ID, Valid: true},
})
err := client.UpdateChat(ctx, child.ID, codersdk.UpdateChatRequest{PinOrder: ptr.Ref(int32(1))})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Cannot pin a child chat.", sdkErr.Message)
result := getChat(ctx, t, client, child.ID)
require.Zero(t, result.PinOrder)
})
}
func TestPostChatMessages(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "initial message for post route test",
},
},
})
require.NoError(t, err)
hasTextPart := func(parts []codersdk.ChatMessagePart, want string) bool {
for _, part := range parts {
if part.Type == codersdk.ChatMessagePartTypeText && part.Text == want {
return true
}
}
return false
}
messageText := "post message route success " + uuid.NewString()
created, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: messageText,
},
},
})
require.NoError(t, err)
if created.Queued {
require.Nil(t, created.Message)
require.NotNil(t, created.QueuedMessage)
require.Equal(t, chat.ID, created.QueuedMessage.ChatID)
require.NotZero(t, created.QueuedMessage.ID)
require.True(t, hasTextPart(created.QueuedMessage.Content, messageText))
require.Eventually(t, func() bool {
messagesResult, getErr := client.GetChatMessages(ctx, chat.ID, nil)
if getErr != nil {
return false
}
for _, queued := range messagesResult.QueuedMessages {
if queued.ID == created.QueuedMessage.ID &&
queued.ChatID == chat.ID &&
hasTextPart(queued.Content, messageText) {
return true
}
}
for _, message := range messagesResult.Messages {
if message.Role == codersdk.ChatMessageRoleUser && hasTextPart(message.Content, messageText) {
return true
}
}
return false
}, testutil.WaitLong, testutil.IntervalFast)
} else {
require.Nil(t, created.QueuedMessage)
require.NotNil(t, created.Message)
require.Equal(t, chat.ID, created.Message.ChatID)
require.Equal(t, codersdk.ChatMessageRoleUser, created.Message.Role)
require.NotZero(t, created.Message.ID)
require.True(t, hasTextPart(created.Message.Content, messageText))
require.Eventually(t, func() bool {
messagesResult, getErr := client.GetChatMessages(ctx, chat.ID, nil)
if getErr != nil {
return false
}
for _, message := range messagesResult.Messages {
if message.ID == created.Message.ID &&
message.Role == codersdk.ChatMessageRoleUser &&
hasTextPart(message.Content, messageText) {
return true
}
}
return false
}, testutil.WaitLong, testutil.IntervalFast)
}
})
t.Run("ProviderDisabledModelConfigRejected", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "initial message before disabled provider switch",
}},
})
require.NoError(t, err)
providerDisabledConfig := createProviderDisabledChatModel(
t,
client,
"openai",
"gpt-4o-send-provider-disabled-"+uuid.NewString(),
)
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "switch to a provider-disabled model",
}},
ModelConfigID: ptr.Ref(providerDisabledConfig.ID),
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid model_config_id: provider is not enabled for this model.", sdkErr.Message)
})
t.Run("CrossOrgModelConfigRejected", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
defaultConfig := createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "initial message before cross-org switch",
}},
})
require.NoError(t, err)
otherOrg := dbgen.Organization(t, db, database.Organization{IsDefault: false})
otherConfig := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: defaultConfig.AIProviderID, Valid: true},
Model: "cross-org-send-" + uuid.NewString(),
Enabled: true,
OrganizationID: otherOrg.ID,
})
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "reject another organization's model",
}},
ModelConfigID: ptr.Ref(otherConfig.ID),
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid model_config_id: model config not found or disabled.", sdkErr.Message)
})
t.Run("HistoricalForeignModelFallsBackToLocalDefault", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
foreignConfig := createChatModel(t, client)
provider := createAIProviderForTest(t, client, "openai-compat", "test-api-key")
chatOrg := dbgen.Organization(t, db, database.Organization{IsDefault: false})
localConfig := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: provider.ID, Valid: true},
Model: "local-send-" + uuid.NewString(),
Enabled: true,
IsDefault: true,
OrganizationID: chatOrg.ID,
})
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, chatOrg.ID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: chatOrg.ID,
OwnerID: member.ID,
LastModelConfigID: foreignConfig.ID,
Title: "historical foreign model",
})
resp, err := memberClient.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "use the local fallback",
}},
})
require.NoError(t, err)
require.NotNil(t, resp.Message)
require.NotNil(t, resp.Message.ModelConfigID)
require.Equal(t, localConfig.ID, *resp.Message.ModelConfigID)
require.Equal(t, firstUser.OrganizationID, foreignConfig.OrganizationID)
})
t.Run("HistoricalForeignModelWithoutLocalDefaultReturnsGuidance", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
foreignConfig := createChatModel(t, client)
chatOrg := dbgen.Organization(t, db, database.Organization{IsDefault: false})
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, chatOrg.ID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: chatOrg.ID,
OwnerID: member.ID,
LastModelConfigID: foreignConfig.ID,
Title: "historical foreign model without fallback",
})
_, err := memberClient.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "require a local fallback",
}},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "No chat model is available in this organization.", sdkErr.Message)
require.Equal(t, "Ask an organization administrator to configure and enable a chat model.", sdkErr.Detail)
})
t.Run("ProviderDisabledDefaultFallbackRejected", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
defaultConfig := createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "initial message before provider disable",
}},
})
require.NoError(t, err)
_, err = client.UpdateAIProvider(ctx, defaultConfig.AIProviderID.String(), codersdk.UpdateAIProviderRequest{
Enabled: ptr.Ref(false),
})
require.NoError(t, err)
// Without an explicit model the fallback walks last model ->
// default, both under the now-disabled provider.
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "message after provider disable",
}},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "No chat model is available in this organization.", sdkErr.Message)
require.Equal(t, "Ask an organization administrator to configure and enable a chat model.", sdkErr.Detail)
})
t.Run("MemberCanCreateChatMessage", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: member.ID,
LastModelConfigID: modelConfig.ID,
Title: "member chat",
})
_, err := memberClient.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "hello from member",
},
},
})
require.NoError(t, err)
})
t.Run("EmptyText", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "initial message for validation test",
},
},
})
require.NoError(t, err)
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: " ",
},
},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid input part.", sdkErr.Message)
require.Equal(t, "content[0].text cannot be empty.", sdkErr.Detail)
})
t.Run("ChatNotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
_, err := client.CreateChatMessage(ctx, uuid.New(), codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
},
},
})
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("ArchivedChat", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, api := newChatClientWithAPI(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
}},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
err = client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Archived: ptr.Ref(true),
})
require.NoError(t, err)
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "should fail",
}},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "archived")
})
}
func waitForChatWatchStatusChangeEvent(
ctx context.Context,
t *testing.T,
conn *websocket.Conn,
chatID uuid.UUID,
) codersdk.ChatWatchEvent {
t.Helper()
for {
var payload codersdk.ChatWatchEvent
err := wsjson.Read(ctx, conn, &payload)
require.NoError(t, err)
if payload.Kind == codersdk.ChatWatchEventKindStatusChange && payload.Chat.ID == chatID {
return payload
}
}
}
func TestSendMessageWithModelOverrideUpdatesLastModelConfigID(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfigA := createChatModel(t, client)
modelConfigB := createAdditionalChatModel(t, client, coderdtest.TestChatProviderOpenAICompat, "gpt-4o-mini-override-"+uuid.NewString())
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfigA.ID,
Title: "mid-chat model switch direct send",
})
resp, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "switch to model b",
}},
ModelConfigID: ptr.Ref(modelConfigB.ID),
})
require.NoError(t, err)
require.False(t, resp.Queued)
require.NotNil(t, resp.Message.ModelConfigID)
require.Equal(t, modelConfigB.ID, *resp.Message.ModelConfigID)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, modelConfigB.ID, storedChat.LastModelConfigID)
messages, err := db.GetChatMessagesByChatID(dbauthz.AsSystemRestricted(ctx), database.GetChatMessagesByChatIDParams{
ChatID: chat.ID,
AfterID: 0,
})
require.NoError(t, err)
// The chat daemon may insert an assistant response before this runs.
userMsg := findUserMessage(t, messages)
require.True(t, userMsg.ModelConfigID.Valid)
require.Equal(t, modelConfigB.ID, userMsg.ModelConfigID.UUID)
}
func TestSendMessageWithReasoningEffortUpdatesLastReasoningEffort(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "per-turn reasoning effort",
})
resp, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "think hard about this",
}},
ReasoningEffort: ptr.Ref("high"),
})
require.NoError(t, err)
require.False(t, resp.Queued)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.True(t, storedChat.LastReasoningEffort.Valid)
require.Equal(t, database.ChatReasoningEffortHigh, storedChat.LastReasoningEffort.ChatReasoningEffort)
messages, err := db.GetChatMessagesByChatID(dbauthz.AsSystemRestricted(ctx), database.GetChatMessagesByChatIDParams{
ChatID: chat.ID,
AfterID: 0,
})
require.NoError(t, err)
userMsg := findUserMessage(t, messages)
require.True(t, userMsg.ReasoningEffort.Valid)
require.Equal(t, database.ChatReasoningEffortHigh, userMsg.ReasoningEffort.ChatReasoningEffort)
// A follow-up message without a reasoning effort leaves the chat's
// last effort unchanged.
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "and another thing",
}},
})
require.NoError(t, err)
storedChat, err = db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.True(t, storedChat.LastReasoningEffort.Valid)
require.Equal(t, database.ChatReasoningEffortHigh, storedChat.LastReasoningEffort.ChatReasoningEffort)
}
func TestSendMessageRejectsInvalidReasoningEffort(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "invalid reasoning effort",
})
_, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
}},
ReasoningEffort: ptr.Ref(" HIGH "),
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid reasoning_effort value.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, `Invalid value " HIGH "`)
require.Contains(t, sdkErr.Detail, "must be one of none, minimal, low, medium, high, xhigh, max")
}
func TestSendMessageQueuesReasoningEffort(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "queued reasoning effort",
})
_, err := db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusRunning,
WorkerID: uuid.NullUUID{UUID: uuid.New(), Valid: true},
StartedAt: sql.NullTime{Time: time.Now(), Valid: true},
HeartbeatAt: sql.NullTime{Time: time.Now(), Valid: true},
LastError: pqtype.NullRawMessage{},
})
require.NoError(t, err)
resp, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "queue this with effort",
}},
ReasoningEffort: ptr.Ref("high"),
BusyBehavior: codersdk.ChatBusyBehaviorQueue,
})
require.NoError(t, err)
require.True(t, resp.Queued)
require.NotNil(t, resp.QueuedMessage)
queuedMessages, err := db.GetChatQueuedMessages(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Len(t, queuedMessages, 1)
require.True(t, queuedMessages[0].ReasoningEffort.Valid)
require.Equal(t, database.ChatReasoningEffortHigh, queuedMessages[0].ReasoningEffort.ChatReasoningEffort)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.False(t, storedChat.LastReasoningEffort.Valid)
}
func TestSendMessageQueuesEffectiveModelConfigID(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfigA := createChatModel(t, client)
modelConfigB := createAdditionalChatModel(t, client, coderdtest.TestChatProviderOpenAICompat, "gpt-4o-mini-queued-"+uuid.NewString())
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfigA.ID,
Title: "mid-chat model switch queued send",
})
_, err := db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusRunning,
WorkerID: uuid.NullUUID{UUID: uuid.New(), Valid: true},
StartedAt: sql.NullTime{Time: time.Now(), Valid: true},
HeartbeatAt: sql.NullTime{Time: time.Now(), Valid: true},
LastError: pqtype.NullRawMessage{},
})
require.NoError(t, err)
resp, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "queue this with model b",
}},
ModelConfigID: ptr.Ref(modelConfigB.ID),
ReasoningEffort: ptr.Ref("high"),
BusyBehavior: codersdk.ChatBusyBehaviorQueue,
})
require.NoError(t, err)
require.True(t, resp.Queued)
require.NotNil(t, resp.QueuedMessage)
require.NotNil(t, resp.QueuedMessage.ModelConfigID)
require.Equal(t, modelConfigB.ID, *resp.QueuedMessage.ModelConfigID)
queuedMessages, err := db.GetChatQueuedMessages(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Len(t, queuedMessages, 1)
require.True(t, queuedMessages[0].ModelConfigID.Valid)
require.Equal(t, modelConfigB.ID, queuedMessages[0].ModelConfigID.UUID)
require.True(t, queuedMessages[0].ReasoningEffort.Valid)
require.Equal(t, database.ChatReasoningEffortHigh, queuedMessages[0].ReasoningEffort.ChatReasoningEffort)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, modelConfigA.ID, storedChat.LastModelConfigID)
require.False(t, storedChat.LastReasoningEffort.Valid)
}
func TestQueuedMessageWithoutOverrideCapturesEnqueueTimeModel(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfigA := createChatModel(t, client)
modelConfigB := createAdditionalChatModel(t, client, coderdtest.TestChatProviderOpenAICompat, "gpt-4o-mini-later-"+uuid.NewString())
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfigA.ID,
Title: "capture queued enqueue-time model",
})
_, err := db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusRunning,
WorkerID: uuid.NullUUID{UUID: uuid.New(), Valid: true},
StartedAt: sql.NullTime{Time: time.Now(), Valid: true},
HeartbeatAt: sql.NullTime{Time: time.Now(), Valid: true},
LastError: pqtype.NullRawMessage{},
})
require.NoError(t, err)
resp, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "queue with stored model",
}},
BusyBehavior: codersdk.ChatBusyBehaviorQueue,
})
require.NoError(t, err)
require.True(t, resp.Queued)
require.NotNil(t, resp.QueuedMessage)
require.NotNil(t, resp.QueuedMessage.ModelConfigID)
require.Equal(t, modelConfigA.ID, *resp.QueuedMessage.ModelConfigID)
_, err = db.UpdateChatLastModelConfigByID(dbauthz.AsSystemRestricted(ctx), database.UpdateChatLastModelConfigByIDParams{
ID: chat.ID,
LastModelConfigID: modelConfigB.ID,
})
require.NoError(t, err)
queuedMessages, err := db.GetChatQueuedMessages(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Len(t, queuedMessages, 1)
require.True(t, queuedMessages[0].ModelConfigID.Valid)
require.Equal(t, modelConfigA.ID, queuedMessages[0].ModelConfigID.UUID)
}
func TestSubsequentSendWithoutOverrideUsesPersistedModel(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
modelConfigB := createAdditionalChatModel(t, client, coderdtest.TestChatProviderOpenAICompat, "gpt-4o-mini-persisted-"+uuid.NewString())
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfigB.ID,
Title: "subsequent send uses persisted model",
})
resp, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "reuse the persisted model",
}},
})
require.NoError(t, err)
require.False(t, resp.Queued)
require.NotNil(t, resp.Message.ModelConfigID)
require.Equal(t, modelConfigB.ID, *resp.Message.ModelConfigID)
messages, err := db.GetChatMessagesByChatID(dbauthz.AsSystemRestricted(ctx), database.GetChatMessagesByChatIDParams{
ChatID: chat.ID,
AfterID: 0,
})
require.NoError(t, err)
// The chat daemon may insert an assistant response before this runs.
userMsg := findUserMessage(t, messages)
require.True(t, userMsg.ModelConfigID.Valid)
require.Equal(t, modelConfigB.ID, userMsg.ModelConfigID.UUID)
}
func TestWatchChatsStatusChangeCarriesUpdatedLastModelConfigID(t *testing.T) {
t.Parallel()
t.Run("DirectSend", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfigA := createChatModel(t, client)
modelConfigB := createAdditionalChatModel(t, client, coderdtest.TestChatProviderOpenAICompat, "gpt-4o-mini-watch-direct-"+uuid.NewString())
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfigA.ID,
Title: "watch direct model switch",
})
conn, err := client.Dial(ctx, "/api/v2/chats/watch", nil)
require.NoError(t, err)
defer conn.Close(websocket.StatusNormalClosure, "done")
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "watch the direct send override",
}},
ModelConfigID: ptr.Ref(modelConfigB.ID),
})
require.NoError(t, err)
event := waitForChatWatchStatusChangeEvent(ctx, t, conn, chat.ID)
require.Equal(t, modelConfigB.ID, event.Chat.LastModelConfigID)
})
t.Run("QueuedPromotion", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfigA := createChatModel(t, client)
modelConfigB := createAdditionalChatModel(t, client, coderdtest.TestChatProviderOpenAICompat, "gpt-4o-mini-watch-promote-"+uuid.NewString())
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfigA.ID,
Title: "watch queued promotion model switch",
})
_, err := db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusRunning,
WorkerID: uuid.NullUUID{UUID: uuid.New(), Valid: true},
StartedAt: sql.NullTime{Time: time.Now(), Valid: true},
HeartbeatAt: sql.NullTime{Time: time.Now(), Valid: true},
LastError: pqtype.NullRawMessage{},
})
require.NoError(t, err)
queuedResp, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "queue the promoted model override",
}},
ModelConfigID: ptr.Ref(modelConfigB.ID),
BusyBehavior: codersdk.ChatBusyBehaviorQueue,
})
require.NoError(t, err)
require.True(t, queuedResp.Queued)
require.NotNil(t, queuedResp.QueuedMessage)
_, err = db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusError,
WorkerID: uuid.NullUUID{},
StartedAt: sql.NullTime{},
HeartbeatAt: sql.NullTime{},
LastError: pqtype.NullRawMessage{},
})
require.NoError(t, err)
conn, err := client.Dial(ctx, "/api/v2/chats/watch", nil)
require.NoError(t, err)
defer conn.Close(websocket.StatusNormalClosure, "done")
promoteRes, err := client.Request(
ctx,
http.MethodPost,
fmt.Sprintf("/api/v2/chats/%s/queue/%d/promote", chat.ID, queuedResp.QueuedMessage.ID),
nil,
)
require.NoError(t, err)
defer promoteRes.Body.Close()
require.Equal(t, http.StatusAccepted, promoteRes.StatusCode)
event := waitForChatWatchStatusChangeEvent(ctx, t, conn, chat.ID)
require.Equal(t, modelConfigB.ID, event.Chat.LastModelConfigID)
})
}
func TestChatMessageWithFileReferences(t *testing.T) {
t.Parallel()
// createChat is a helper that creates a chat so we can post messages to it.
createChatForTest := func(t *testing.T, client *codersdk.ExperimentalClient, orgID uuid.UUID) codersdk.Chat {
t.Helper()
ctx := testutil.Context(t, testutil.WaitLong)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: orgID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "initial message",
}},
})
require.NoError(t, err)
return chat
}
t.Run("FileReferenceOnly", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChatForTest(t, client, firstUser.OrganizationID)
created, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeFileReference,
FileName: "main.go",
StartLine: 10,
EndLine: 15,
Content: "func broken() {}",
}},
})
require.NoError(t, err)
// File-reference parts are stored as structured parts.
checkFileRef := func(part codersdk.ChatMessagePart) bool {
return part.Type == codersdk.ChatMessagePartTypeFileReference &&
part.FileName == "main.go" &&
part.StartLine == 10 &&
part.EndLine == 15 &&
part.Content == "func broken() {}"
}
var found bool
require.Eventually(t, func() bool {
messagesResult, getErr := client.GetChatMessages(ctx, chat.ID, nil)
if getErr != nil {
return false
}
for _, message := range messagesResult.Messages {
if message.Role != codersdk.ChatMessageRoleUser {
continue
}
for _, part := range message.Content {
if checkFileRef(part) {
found = true
return true
}
}
}
// The message may have been queued.
if created.Queued && created.QueuedMessage != nil {
for _, queued := range messagesResult.QueuedMessages {
for _, part := range queued.Content {
if checkFileRef(part) {
found = true
return true
}
}
}
}
return false
}, testutil.WaitLong, testutil.IntervalFast)
require.True(t, found, "expected to find file-reference part in stored message")
})
t.Run("FileReferenceSingleLine", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChatForTest(t, client, firstUser.OrganizationID)
created, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeFileReference,
FileName: "lib/utils.ts",
StartLine: 42,
EndLine: 42,
Content: "const x = 1;",
}},
})
require.NoError(t, err)
checkFileRef := func(part codersdk.ChatMessagePart) bool {
return part.Type == codersdk.ChatMessagePartTypeFileReference &&
part.FileName == "lib/utils.ts" &&
part.StartLine == 42 &&
part.EndLine == 42 &&
part.Content == "const x = 1;"
}
require.Eventually(t, func() bool {
messagesResult, getErr := client.GetChatMessages(ctx, chat.ID, nil)
if getErr != nil {
return false
}
for _, msg := range messagesResult.Messages {
for _, part := range msg.Content {
if checkFileRef(part) {
return true
}
}
}
if created.Queued && created.QueuedMessage != nil {
for _, queued := range messagesResult.QueuedMessages {
for _, part := range queued.Content {
if checkFileRef(part) {
return true
}
}
}
}
return false
}, testutil.WaitLong, testutil.IntervalFast)
})
t.Run("FileReferenceWithoutContent", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChatForTest(t, client, firstUser.OrganizationID)
created, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeFileReference,
FileName: "README.md",
StartLine: 1,
EndLine: 1,
// No code content — just a file reference.
}},
})
require.NoError(t, err)
checkFileRef := func(part codersdk.ChatMessagePart) bool {
return part.Type == codersdk.ChatMessagePartTypeFileReference &&
part.FileName == "README.md" &&
part.StartLine == 1 &&
part.EndLine == 1 &&
part.Content == ""
}
require.Eventually(t, func() bool {
messagesResult, getErr := client.GetChatMessages(ctx, chat.ID, nil)
if getErr != nil {
return false
}
for _, msg := range messagesResult.Messages {
for _, part := range msg.Content {
if checkFileRef(part) {
return true
}
}
}
if created.Queued && created.QueuedMessage != nil {
for _, queued := range messagesResult.QueuedMessages {
for _, part := range queued.Content {
if checkFileRef(part) {
return true
}
}
}
}
return false
}, testutil.WaitLong, testutil.IntervalFast)
})
t.Run("FileReferenceWithCode", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChatForTest(t, client, firstUser.OrganizationID)
created, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeFileReference,
FileName: "server.go",
StartLine: 5,
EndLine: 8,
Content: "func main() {\n\tfmt.Println()\n}",
}},
})
require.NoError(t, err)
checkFileRef := func(part codersdk.ChatMessagePart) bool {
return part.Type == codersdk.ChatMessagePartTypeFileReference &&
part.FileName == "server.go" &&
part.StartLine == 5 &&
part.EndLine == 8 &&
part.Content == "func main() {\n\tfmt.Println()\n}"
}
require.Eventually(t, func() bool {
messagesResult, getErr := client.GetChatMessages(ctx, chat.ID, nil)
if getErr != nil {
return false
}
for _, msg := range messagesResult.Messages {
for _, part := range msg.Content {
if checkFileRef(part) {
return true
}
}
}
if created.Queued && created.QueuedMessage != nil {
for _, queued := range messagesResult.QueuedMessages {
for _, part := range queued.Content {
if checkFileRef(part) {
return true
}
}
}
}
return false
}, testutil.WaitLong, testutil.IntervalFast)
})
t.Run("InterleavedTextAndFileReferences", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChatForTest(t, client, firstUser.OrganizationID)
created, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "Please review these two issues:",
},
{
Type: codersdk.ChatInputPartTypeFileReference,
FileName: "a.go",
StartLine: 1,
EndLine: 3,
Content: "line1\nline2\nline3",
},
{
Type: codersdk.ChatInputPartTypeText,
Text: "first issue",
},
{
Type: codersdk.ChatInputPartTypeText,
Text: "and also:",
},
{
Type: codersdk.ChatInputPartTypeFileReference,
FileName: "b.go",
StartLine: 10,
EndLine: 10,
Content: "return nil",
},
{
Type: codersdk.ChatInputPartTypeText,
Text: "second issue",
},
},
})
require.NoError(t, err)
// Verify that all six parts are stored in order with
// correct types: text, file-reference, text, text,
// file-reference, text.
type wantPart struct {
typ codersdk.ChatMessagePartType
text string
fileName string
startLine int
endLine int
content string
}
want := []wantPart{
{typ: codersdk.ChatMessagePartTypeText, text: "Please review these two issues:"},
{typ: codersdk.ChatMessagePartTypeFileReference, fileName: "a.go", startLine: 1, endLine: 3, content: "line1\nline2\nline3"},
{typ: codersdk.ChatMessagePartTypeText, text: "first issue"},
{typ: codersdk.ChatMessagePartTypeText, text: "and also:"},
{typ: codersdk.ChatMessagePartTypeFileReference, fileName: "b.go", startLine: 10, endLine: 10, content: "return nil"},
{typ: codersdk.ChatMessagePartTypeText, text: "second issue"},
}
require.Eventually(t, func() bool {
messagesResult, getErr := client.GetChatMessages(ctx, chat.ID, nil)
if getErr != nil {
return false
}
checkParts := func(parts []codersdk.ChatMessagePart) bool {
if len(parts) != len(want) {
return false
}
for i, w := range want {
p := parts[i]
if p.Type != w.typ {
return false
}
switch w.typ {
case codersdk.ChatMessagePartTypeText:
if p.Text != w.text {
return false
}
case codersdk.ChatMessagePartTypeFileReference:
if p.FileName != w.fileName ||
p.StartLine != w.startLine ||
p.EndLine != w.endLine ||
p.Content != w.content {
return false
}
}
}
return true
}
for _, msg := range messagesResult.Messages {
if msg.Role == codersdk.ChatMessageRoleUser && checkParts(msg.Content) {
return true
}
}
if created.Queued && created.QueuedMessage != nil {
for _, queued := range messagesResult.QueuedMessages {
if checkParts(queued.Content) {
return true
}
}
}
return false
}, testutil.WaitLong, testutil.IntervalFast)
})
t.Run("EmptyFileName", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat := createChatForTest(t, client, firstUser.OrganizationID)
_, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeFileReference,
FileName: "",
StartLine: 1,
EndLine: 1,
}},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid input part.", sdkErr.Message)
require.Equal(t, "content[0].file_name cannot be empty for file-reference.", sdkErr.Detail)
})
t.Run("CreateChatWithFileReference", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// File references should also work in the initial CreateChat call.
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeFileReference,
FileName: "bug.py",
StartLine: 7,
EndLine: 7,
Content: "x = None",
}},
})
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, chat.ID)
// Title is derived from the text parts. For file-references
// the formatted text becomes the title source.
require.NotEmpty(t, chat.Title)
})
}
func TestChatMessageWithFiles(t *testing.T) {
t.Parallel()
t.Run("FileOnly", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Upload a file.
pngData := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploadResp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "test.png", bytes.NewReader(pngData))
require.NoError(t, err)
// Create a chat with text first.
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "initial message",
},
},
})
require.NoError(t, err)
// Send a file-only message (no text).
resp, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeFile,
FileID: uploadResp.ID,
},
},
})
require.NoError(t, err)
// Verify the message was accepted.
if resp.Queued {
require.NotNil(t, resp.QueuedMessage)
} else {
require.Equal(t, codersdk.ChatMessageRoleUser, resp.Message.Role)
}
})
t.Run("TextAndFile", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Upload a file.
pngData := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploadResp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "test.png", bytes.NewReader(pngData))
require.NoError(t, err)
// Create a chat with text first.
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "initial message",
},
},
})
require.NoError(t, err)
// Send a message with both text and file.
resp, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "here is an image",
},
{
Type: codersdk.ChatInputPartTypeFile,
FileID: uploadResp.ID,
},
},
})
require.NoError(t, err)
if resp.Queued {
require.NotNil(t, resp.QueuedMessage)
} else {
require.Equal(t, codersdk.ChatMessageRoleUser, resp.Message.Role)
}
// Verify file parts omit inline data in the API response.
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
for _, msg := range messagesResult.Messages {
for _, part := range msg.Content {
if part.Type == codersdk.ChatMessagePartTypeFile {
require.True(t, part.FileID.Valid, "file part should have a valid file_id")
require.Equal(t, uploadResp.ID, part.FileID.UUID)
require.Nil(t, part.Data, "file data should not be sent when file_id is present")
}
}
}
})
t.Run("FileOnlyOnCreate", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Upload a file.
pngData := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploadResp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "test.png", bytes.NewReader(pngData))
require.NoError(t, err)
// Create a new chat with only a file part.
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeFile,
FileID: uploadResp.ID,
},
},
})
require.NoError(t, err)
// With no text and no pasted-text attachment, the fallback
// title derivation yields "New Chat".
require.Equal(t, "New Chat", chat.Title)
require.Len(t, chat.Files, 1)
f := chat.Files[0]
require.Equal(t, uploadResp.ID, f.ID)
require.Equal(t, firstUser.UserID, f.OwnerID)
require.NotEqual(t, uuid.Nil, f.OrganizationID)
require.Equal(t, "image/png", f.MimeType)
require.Equal(t, int64(len(pngData)), f.SizeBytes)
require.Equal(t, "test.png", f.Name)
require.NotZero(t, f.CreatedAt)
})
t.Run("PasteOnlyOnCreate", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Upload a synthetic pasted-text attachment as created by the
// chat UI when a large paste is collapsed into a file.
uploadResp, err := client.UploadChatFile(
ctx,
firstUser.OrganizationID,
"text/plain",
"pasted-text-2026-01-02-03-04-05.txt",
strings.NewReader("Fix the flaky test in coderd please"),
)
require.NoError(t, err)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeFile,
FileID: uploadResp.ID,
},
},
})
require.NoError(t, err)
// The fallback title derives from the pasted attachment
// content instead of "New Chat".
require.Equal(t, "Fix the flaky test in coderd please", chat.Title)
})
t.Run("InvalidFileID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Create a chat with text first.
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "initial message",
},
},
})
require.NoError(t, err)
// Send a message with a non-existent file ID.
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeFile,
FileID: uuid.New(),
},
},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid input part.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, "does not exist")
})
t.Run("UnsupportedPromptInputFileType", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, store := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "initial message"},
},
})
require.NoError(t, err)
//nolint:gocritic // Using AsChatd to mimic an agent-created artifact.
chatdCtx := dbauthz.AsChatd(ctx)
fileRow, err := store.InsertChatFile(chatdCtx, database.InsertChatFileParams{
OwnerID: firstUser.UserID,
OrganizationID: firstUser.OrganizationID,
Name: "artifact.zip",
Mimetype: "application/zip",
Data: []byte("zip data"),
})
require.NoError(t, err)
rejected, err := store.LinkChatFiles(chatdCtx, database.LinkChatFilesParams{
ChatID: chat.ID,
MaxFileLinks: int32(codersdk.DefaultChatMaxAttachmentsPerChat),
FileIds: []uuid.UUID{fileRow.ID},
})
require.NoError(t, err)
require.Zero(t, rejected)
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeFile, FileID: fileRow.ID},
},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid input part.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, "cannot be used as prompt input")
require.Contains(t, sdkErr.Detail, "application/json")
})
t.Run("FilesLinkedOnSend", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Create a text-only chat (no files initially).
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "no files yet"},
},
})
require.NoError(t, err)
// Upload a file.
pngData := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploadResp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "linked.png", bytes.NewReader(pngData))
require.NoError(t, err)
// Send a message with the file.
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "here is a file"},
{Type: codersdk.ChatInputPartTypeFile, FileID: uploadResp.ID},
},
})
require.NoError(t, err)
// GET the chat — file should be linked.
chatResult, err := client.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Len(t, chatResult.Files, 1)
require.Equal(t, uploadResp.ID, chatResult.Files[0].ID)
require.Equal(t, "linked.png", chatResult.Files[0].Name)
})
t.Run("DedupFileIDs", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Upload a file.
pngData := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploadResp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "dedup.png", bytes.NewReader(pngData))
require.NoError(t, err)
// Create a chat with a file.
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "first mention"}, {Type: codersdk.ChatInputPartTypeFile, FileID: uploadResp.ID},
},
})
require.NoError(t, err)
// Send another message with the SAME file.
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "same file again"},
{Type: codersdk.ChatInputPartTypeFile, FileID: uploadResp.ID},
},
})
require.NoError(t, err)
// GET — should have exactly 1 file (deduped by SQL DISTINCT).
chatResult, err := client.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Len(t, chatResult.Files, 1, "duplicate file IDs should be deduped")
require.Equal(t, uploadResp.ID, chatResult.Files[0].ID)
})
attachmentLimitCases := chatLimitCases(func(c *codersdk.ChatConfig) *serpent.Int64 { return &c.MaxAttachmentsPerChat },
codersdk.DefaultChatMaxAttachmentsPerChat, 3, 60)
t.Run("FileCapEvictsOldest", func(t *testing.T) {
t.Parallel()
for _, lc := range attachmentLimitCases {
t.Run(lc.name, func(t *testing.T) {
t.Parallel()
client := newChatClient(t, lc.configure)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
ctx := testutil.Context(t, testutil.WaitLong)
fileIDs := uploadChatPNGs(ctx, t, client, firstUser.OrganizationID, "file", lc.limit+1)
capped, extra := fileIDs[:lc.limit], fileIDs[lc.limit]
parts := []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "max files"},
}
for _, fid := range capped {
parts = append(parts, codersdk.ChatInputPart{Type: codersdk.ChatInputPartTypeFile, FileID: fid})
}
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{OrganizationID: firstUser.OrganizationID, Content: parts})
require.NoError(t, err)
require.Len(t, chat.Files, lc.limit, "all files should be linked on creation")
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "one too many"},
{Type: codersdk.ChatInputPartTypeFile, FileID: extra},
},
})
require.NoError(t, err, "linking past the cap should evict the oldest file")
linked := linkedChatFileIDs(ctx, t, client, chat.ID)
require.Len(t, linked, lc.limit, "file count should not exceed the cap")
require.Contains(t, linked, extra)
require.NotContains(t, linked, capped[0], "the oldest file should be evicted")
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "re-reference existing"},
{Type: codersdk.ChatInputPartTypeFile, FileID: capped[1]},
},
})
require.NoError(t, err, "re-referencing an already-linked file must not count against the cap")
require.Equal(t, linked, linkedChatFileIDs(ctx, t, client, chat.ID), "re-referencing an already-linked file must not evict anything")
})
}
})
t.Run("FileCapOnCreate", func(t *testing.T) {
t.Parallel()
for _, lc := range attachmentLimitCases {
t.Run(lc.name, func(t *testing.T) {
t.Parallel()
client := newChatClient(t, lc.configure)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
ctx := testutil.Context(t, testutil.WaitLong)
parts := []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "over cap on create"},
}
for _, fid := range uploadChatPNGs(ctx, t, client, firstUser.OrganizationID, "create", lc.limit+1) {
parts = append(parts, codersdk.ChatInputPart{Type: codersdk.ChatInputPartTypeFile, FileID: fid})
}
_, err := client.CreateChat(ctx, codersdk.CreateChatRequest{OrganizationID: firstUser.OrganizationID, Content: parts})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "attachment limit")
require.Contains(t, sdkErr.Detail, fmt.Sprintf("at most %d attachments", lc.limit))
chats, err := client.ListChats(ctx, nil)
require.NoError(t, err)
require.Empty(t, chats, "rejected create should not persist a chat")
})
}
})
}
func TestPatchChatMessage(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "hello before edit",
},
},
})
require.NoError(t, err)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var userMessageID int64
for _, message := range messagesResult.Messages {
if message.Role == codersdk.ChatMessageRoleUser {
userMessageID = message.ID
break
}
}
require.NotZero(t, userMessageID)
edited, err := client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "hello after edit",
},
},
})
require.NoError(t, err)
// The edited message is soft-deleted and a new one is inserted,
// so the returned ID will differ from the original.
require.NotEqual(t, userMessageID, edited.Message.ID)
require.Equal(t, codersdk.ChatMessageRoleUser, edited.Message.Role)
foundEditedText := false
for _, part := range edited.Message.Content {
if part.Type == codersdk.ChatMessagePartTypeText && part.Text == "hello after edit" {
foundEditedText = true
}
}
require.True(t, foundEditedText)
messagesResult, err = client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
foundEditedInChat := false
foundOriginalInChat := false
for _, message := range messagesResult.Messages {
if message.Role != codersdk.ChatMessageRoleUser {
continue
}
for _, part := range message.Content {
if part.Type != codersdk.ChatMessagePartTypeText {
continue
}
if part.Text == "hello after edit" {
foundEditedInChat = true
}
if part.Text == "hello before edit" {
foundOriginalInChat = true
}
}
}
require.True(t, foundEditedInChat)
require.False(t, foundOriginalInChat)
})
t.Run("MCPServerIDsApplied", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
orgConfig := dbgen.MCPServerConfig(t, db, database.MCPServerConfig{
OrganizationID: firstUser.OrganizationID,
Enabled: true,
})
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "before mcp edit",
}},
})
require.NoError(t, err)
require.Empty(t, chat.MCPServerIDs)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
userMessageID := messagesResult.Messages[0].ID
edited, err := client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "edit enabling the mcp server",
}},
MCPServerIDs: &[]uuid.UUID{orgConfig.ID},
})
require.NoError(t, err)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, []uuid.UUID{orgConfig.ID}, storedChat.MCPServerIDs)
// Omitting the field preserves the persisted selection.
_, err = client.EditChatMessage(ctx, chat.ID, edited.Message.ID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "edit without an mcp selection",
}},
})
require.NoError(t, err)
storedChat, err = db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, []uuid.UUID{orgConfig.ID}, storedChat.MCPServerIDs)
})
t.Run("MCPServerIDsInvalidRejected", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "before invalid mcp edit",
}},
})
require.NoError(t, err)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
userMessageID := messagesResult.Messages[0].ID
unknownID := uuid.New()
_, err = client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "edit selecting an unknown mcp server",
}},
MCPServerIDs: &[]uuid.UUID{unknownID},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "One or more MCP server IDs are invalid or disabled.", sdkErr.Message)
require.Equal(t, "Invalid IDs: "+unknownID.String(), sdkErr.Detail)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Empty(t, storedChat.MCPServerIDs)
})
t.Run("CrossOrgModelConfigRejected", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
defaultConfig := createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "before cross-org edit",
}},
})
require.NoError(t, err)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
userMessageID := messagesResult.Messages[0].ID
otherOrg := dbgen.Organization(t, db, database.Organization{IsDefault: false})
otherConfig := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: defaultConfig.AIProviderID, Valid: true},
Model: "cross-org-edit-" + uuid.NewString(),
Enabled: true,
OrganizationID: otherOrg.ID,
})
_, err = client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "reject another organization's model",
}},
ModelConfigID: ptr.Ref(otherConfig.ID),
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid model_config_id: model config not found or disabled.", sdkErr.Message)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, defaultConfig.ID, storedChat.LastModelConfigID)
})
t.Run("HistoricalForeignModelFallsBackToLocalDefault", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
foreignConfig := createChatModel(t, client)
provider := createAIProviderForTest(t, client, "openai-compat", "test-api-key")
chatOrg := dbgen.Organization(t, db, database.Organization{IsDefault: false})
localConfig := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: provider.ID, Valid: true},
Model: "local-edit-" + uuid.NewString(),
Enabled: true,
IsDefault: true,
OrganizationID: chatOrg.ID,
})
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, chatOrg.ID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: chatOrg.ID,
OwnerID: member.ID,
LastModelConfigID: foreignConfig.ID,
Title: "historical foreign model edit",
})
content, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{codersdk.ChatMessageText("before edit")})
require.NoError(t, err)
message := dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
CreatedBy: uuid.NullUUID{UUID: member.ID, Valid: true},
ModelConfigID: uuid.NullUUID{UUID: foreignConfig.ID, Valid: true},
Role: database.ChatMessageRoleUser,
Visibility: database.ChatMessageVisibilityBoth,
Content: content,
})
edited, err := memberClient.EditChatMessage(ctx, chat.ID, message.ID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "after edit",
}},
})
require.NoError(t, err)
require.NotNil(t, edited.Message.ModelConfigID)
require.Equal(t, localConfig.ID, *edited.Message.ModelConfigID)
})
t.Run("HistoricalForeignModelWithoutLocalDefaultReturnsGuidance", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
foreignConfig := createChatModel(t, client)
chatOrg := dbgen.Organization(t, db, database.Organization{IsDefault: false})
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, chatOrg.ID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: chatOrg.ID,
OwnerID: member.ID,
LastModelConfigID: foreignConfig.ID,
Title: "historical foreign model edit without fallback",
})
content, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{codersdk.ChatMessageText("before edit")})
require.NoError(t, err)
message := dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
CreatedBy: uuid.NullUUID{UUID: member.ID, Valid: true},
ModelConfigID: uuid.NullUUID{UUID: foreignConfig.ID, Valid: true},
Role: database.ChatMessageRoleUser,
Visibility: database.ChatMessageVisibilityBoth,
Content: content,
})
_, err = memberClient.EditChatMessage(ctx, chat.ID, message.ID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "after edit",
}},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "No chat model is available in this organization.", sdkErr.Message)
require.Equal(t, "Ask an organization administrator to configure and enable a chat model.", sdkErr.Detail)
})
t.Run("ReasoningEffort", func(t *testing.T) {
t.Parallel()
for _, tc := range []struct {
name string
requested *string
want string
}{
{name: "PreservesByDefault", want: "low"},
{name: "Overrides", requested: ptr.Ref("high"), want: "high"},
} {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "before edit effort",
}},
ReasoningEffort: ptr.Ref("low"),
})
require.NoError(t, err)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
userMessageID := messagesResult.Messages[0].ID
edited, err := client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "after edit effort",
}},
ReasoningEffort: tc.requested,
})
require.NoError(t, err)
storedMessage, err := db.GetChatMessageByID(dbauthz.AsSystemRestricted(ctx), edited.Message.ID)
require.NoError(t, err)
require.True(t, storedMessage.ReasoningEffort.Valid)
require.Equal(t, database.ChatReasoningEffort(tc.want), storedMessage.ReasoningEffort.ChatReasoningEffort)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.True(t, storedChat.LastReasoningEffort.Valid)
require.Equal(t, database.ChatReasoningEffort(tc.want), storedChat.LastReasoningEffort.ChatReasoningEffort)
})
}
})
t.Run("RejectsInvalidReasoningEffort", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "before invalid effort edit",
}},
})
require.NoError(t, err)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
userMessageID := messagesResult.Messages[0].ID
_, err = client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "after invalid effort edit",
}},
ReasoningEffort: ptr.Ref(" HIGH "),
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid reasoning_effort value.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, `Invalid value " HIGH "`)
require.Contains(t, sdkErr.Detail, "must be one of none, minimal, low, medium, high, xhigh, max")
})
t.Run("PreservesFileID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Upload a file.
pngData := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploadResp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "test.png", bytes.NewReader(pngData))
require.NoError(t, err)
// Create a chat with a text + file part.
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "before edit with file",
},
{
Type: codersdk.ChatInputPartTypeFile,
FileID: uploadResp.ID,
},
},
})
require.NoError(t, err)
// Find the user message ID.
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var userMessageID int64
for _, message := range messagesResult.Messages {
if message.Role == codersdk.ChatMessageRoleUser {
userMessageID = message.ID
break
}
}
require.NotZero(t, userMessageID)
// Edit the message: new text, same file_id.
edited, err := client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "after edit with file",
},
{
Type: codersdk.ChatInputPartTypeFile,
FileID: uploadResp.ID,
},
},
})
require.NoError(t, err)
// The edited message is soft-deleted and a new one is inserted,
// so the returned ID will differ from the original.
require.NotEqual(t, userMessageID, edited.Message.ID)
// Assert the edit response preserves the file_id.
var foundText, foundFile bool
for _, part := range edited.Message.Content {
if part.Type == codersdk.ChatMessagePartTypeText && part.Text == "after edit with file" {
foundText = true
}
if part.Type == codersdk.ChatMessagePartTypeFile && part.FileID.Valid && part.FileID.UUID == uploadResp.ID {
foundFile = true
require.Nil(t, part.Data, "file data should not be sent when file_id is present")
}
}
require.True(t, foundText, "edited message should contain updated text")
require.True(t, foundFile, "edited message should preserve file_id")
// GET the chat messages and verify the file_id persists.
messagesResult, err = client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var foundTextInChat, foundFileInChat bool
for _, message := range messagesResult.Messages {
if message.Role != codersdk.ChatMessageRoleUser {
continue
}
for _, part := range message.Content {
if part.Type == codersdk.ChatMessagePartTypeText && part.Text == "after edit with file" {
foundTextInChat = true
}
if part.Type == codersdk.ChatMessagePartTypeFile && part.FileID.Valid && part.FileID.UUID == uploadResp.ID {
foundFileInChat = true
require.Nil(t, part.Data, "file data should not be sent when file_id is present")
}
}
}
require.True(t, foundTextInChat, "chat should contain edited text")
require.True(t, foundFileInChat, "chat should preserve file_id after edit")
})
t.Run("MessageNotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
},
},
})
require.NoError(t, err)
_, err = client.EditChatMessage(ctx, chat.ID, 999999, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "edited",
},
},
})
sdkErr := requireSDKError(t, err, http.StatusNotFound)
require.Equal(t, "Chat message not found.", sdkErr.Message)
})
t.Run("InvalidMessageID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
},
},
})
require.NoError(t, err)
res, err := client.Request(
ctx,
http.MethodPatch,
fmt.Sprintf("/api/v2/chats/%s/messages/not-an-int", chat.ID),
codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "ignored",
},
},
},
)
require.NoError(t, err)
defer res.Body.Close()
err = codersdk.ReadBodyAsError(res)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid chat message ID.", sdkErr.Message)
})
t.Run("FilesLinkedOnEdit", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
// Create a text-only chat.
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "before file edit"},
},
})
require.NoError(t, err)
// Upload a file.
pngData := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploadResp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "edit-linked.png", bytes.NewReader(pngData))
require.NoError(t, err)
// Find the user message ID.
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var userMessageID int64
for _, msg := range messagesResult.Messages {
if msg.Role == codersdk.ChatMessageRoleUser {
userMessageID = msg.ID
break
}
}
require.NotZero(t, userMessageID)
// Edit the message to include the file.
_, err = client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "after file edit"},
{Type: codersdk.ChatInputPartTypeFile, FileID: uploadResp.ID},
},
})
require.NoError(t, err)
// GET the chat — file should be linked.
chatResult, err := client.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Len(t, chatResult.Files, 1)
f := chatResult.Files[0]
require.Equal(t, uploadResp.ID, f.ID)
require.Equal(t, "edit-linked.png", f.Name)
require.Equal(t, "image/png", f.MimeType)
})
t.Run("CapEvictsOldestOnEdit", func(t *testing.T) {
t.Parallel()
limitCases := chatLimitCases(func(c *codersdk.ChatConfig) *serpent.Int64 { return &c.MaxAttachmentsPerChat },
codersdk.DefaultChatMaxAttachmentsPerChat, 3, 60)
for _, lc := range limitCases {
t.Run(lc.name, func(t *testing.T) {
t.Parallel()
client := newChatClient(t, lc.configure)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
ctx := testutil.Context(t, testutil.WaitLong)
fileIDs := uploadChatPNGs(ctx, t, client, firstUser.OrganizationID, "cap", lc.limit+1)
capped, extra := fileIDs[:lc.limit], fileIDs[lc.limit]
parts := []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "fill to cap"},
}
for _, fid := range capped {
parts = append(parts, codersdk.ChatInputPart{Type: codersdk.ChatInputPartTypeFile, FileID: fid})
}
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{OrganizationID: firstUser.OrganizationID, Content: parts})
require.NoError(t, err)
require.Len(t, chat.Files, lc.limit)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var userMessageID int64
for _, msg := range messagesResult.Messages {
if msg.Role == codersdk.ChatMessageRoleUser {
userMessageID = msg.ID
break
}
}
require.NotZero(t, userMessageID)
_, err = client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "edit with extra file"},
{Type: codersdk.ChatInputPartTypeFile, FileID: extra},
},
})
require.NoError(t, err, "edit past the cap should evict the oldest file")
linked := linkedChatFileIDs(ctx, t, client, chat.ID)
require.Len(t, linked, lc.limit, "file count should not exceed the cap")
require.Contains(t, linked, extra)
require.NotContains(t, linked, capped[0], "the oldest file should be evicted")
})
}
})
t.Run("ArchivedChat", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, api := newChatClientWithAPI(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello before edit",
}},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var userMessageID int64
for _, message := range messagesResult.Messages {
if message.Role == codersdk.ChatMessageRoleUser {
userMessageID = message.ID
break
}
}
require.NotZero(t, userMessageID)
err = client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Archived: ptr.Ref(true),
})
require.NoError(t, err)
_, err = client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "should fail",
}},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "archived")
})
t.Run("ChangesModel", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
defaultModel := createChatModel(t, client)
overrideModel := createAdditionalChatModel(
t,
client,
coderdtest.TestChatProviderOpenAICompat,
"gpt-4o-mini-edit-override",
)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello before edit",
}},
})
require.NoError(t, err)
require.Equal(t, defaultModel.ID, chat.LastModelConfigID,
"chat starts on the default model")
// Wait for the initial chat processing to complete before
// editing. CreateChat sets the chat to pending and the daemon
// processes it asynchronously; editing while that first round
// is still running can race with message insertions that
// overwrite last_model_config_id.
testutil.Eventually(ctx, t, func(ctx context.Context) bool {
c, getErr := client.GetChat(ctx, chat.ID)
if getErr != nil {
return false
}
return c.Status != codersdk.ChatStatusRunning
}, testutil.IntervalFast, "initial chat processing did not finish")
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var userMessageID int64
for _, message := range messagesResult.Messages {
if message.Role == codersdk.ChatMessageRoleUser {
userMessageID = message.ID
break
}
}
require.NotZero(t, userMessageID)
edited, err := client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello after edit with new model",
}},
ModelConfigID: &overrideModel.ID,
})
require.NoError(t, err)
require.NotNil(t, edited.Message.ModelConfigID,
"edited message must carry a model config")
require.Equal(t, overrideModel.ID, *edited.Message.ModelConfigID,
"replacement message must use the requested model")
// Wait for the second round of processing (triggered by the
// edit) to complete, then verify last_model_config_id.
// Reading immediately after EditChatMessage can race with the
// daemon re-processing the now-pending chat.
testutil.Eventually(ctx, t, func(ctx context.Context) bool {
c, getErr := client.GetChat(ctx, chat.ID)
if getErr != nil {
return false
}
return c.Status != codersdk.ChatStatusRunning
}, testutil.IntervalFast, "post-edit chat processing did not finish")
updatedChat, err := client.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, overrideModel.ID, updatedChat.LastModelConfigID,
"chat last_model_config_id must advance so the next assistant turn uses the new model")
})
t.Run("InvalidModelConfigID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
}},
})
require.NoError(t, err)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var userMessageID int64
for _, message := range messagesResult.Messages {
if message.Role == codersdk.ChatMessageRoleUser {
userMessageID = message.ID
break
}
}
require.NotZero(t, userMessageID)
unknownID := uuid.New()
_, err = client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "edited",
}},
ModelConfigID: &unknownID,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid model_config_id: model config not found or disabled.", sdkErr.Message)
})
t.Run("ProviderDisabledModelConfigID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
}},
})
require.NoError(t, err)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var userMessageID int64
for _, message := range messagesResult.Messages {
if message.Role == codersdk.ChatMessageRoleUser {
userMessageID = message.ID
break
}
}
require.NotZero(t, userMessageID)
providerDisabledConfig := createProviderDisabledChatModel(
t,
client,
"openai",
"gpt-4o-edit-provider-disabled-"+uuid.NewString(),
)
_, err = client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "edited with provider-disabled model",
}},
ModelConfigID: &providerDisabledConfig.ID,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid model_config_id: provider is not enabled for this model.", sdkErr.Message)
})
t.Run("ProviderDisabledPreservedModelRejected", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
defaultConfig := createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello before provider disable",
}},
})
require.NoError(t, err)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var userMessageID int64
for _, message := range messagesResult.Messages {
if message.Role == codersdk.ChatMessageRoleUser {
userMessageID = message.ID
break
}
}
require.NotZero(t, userMessageID)
_, err = client.UpdateAIProvider(ctx, defaultConfig.AIProviderID.String(), codersdk.UpdateAIProviderRequest{
Enabled: ptr.Ref(false),
})
require.NoError(t, err)
// Editing without model_config_id preserves the edited message's
// original model; its provider and the default's are now disabled.
_, err = client.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "edited after provider disable",
}},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "No chat model is available in this organization.", sdkErr.Message)
require.Equal(t, "Ask an organization administrator to configure and enable a chat model.", sdkErr.Detail)
})
}
// readStreamChatSnapshot reads through the initial status event, which
// follows replayed messages.
func readStreamChatSnapshot(ctx context.Context, t *testing.T, events <-chan codersdk.ChatStreamEvent) []codersdk.ChatStreamEvent {
t.Helper()
var snapshot []codersdk.ChatStreamEvent
for {
select {
case <-ctx.Done():
require.FailNow(t, "timed out waiting for the snapshot status event")
case event, ok := <-events:
require.True(t, ok, "stream closed before the snapshot status event")
require.NotEqual(t, codersdk.ChatStreamEventTypeError, event.Type)
snapshot = append(snapshot, event)
if event.Type == codersdk.ChatStreamEventTypeStatus {
return snapshot
}
}
}
}
func streamChatEventsOfType(events []codersdk.ChatStreamEvent, eventType codersdk.ChatStreamEventType) []codersdk.ChatStreamEvent {
var matched []codersdk.ChatStreamEvent
for _, event := range events {
if event.Type == eventType {
matched = append(matched, event)
}
}
return matched
}
func streamChatSnapshotHasText(events []codersdk.ChatStreamEvent, text string) bool {
for _, event := range streamChatEventsOfType(events, codersdk.ChatStreamEventTypeMessage) {
for _, part := range event.Message.Content {
if part.Type == codersdk.ChatMessagePartTypeText && part.Text == text {
return true
}
}
}
return false
}
func TestStreamChat(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
const initialMessage = "stream chat route initial message"
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: initialMessage,
},
},
})
require.NoError(t, err)
events, closer, err := client.StreamChat(ctx, chat.ID, nil)
require.NoError(t, err)
defer closer.Close()
hasTextPart := func(parts []codersdk.ChatMessagePart, want string) bool {
for _, part := range parts {
if part.Type == codersdk.ChatMessagePartTypeText && part.Text == want {
return true
}
}
return false
}
foundInitialUserMessage := false
for !foundInitialUserMessage {
select {
case <-ctx.Done():
require.FailNow(t, "timed out waiting for expected stream chat event")
case event, ok := <-events:
require.True(t, ok, "stream closed before expected event")
require.Equal(t, chat.ID, event.ChatID)
require.NotEqual(t, codersdk.ChatStreamEventTypeError, event.Type)
if event.Type == codersdk.ChatStreamEventTypeMessage &&
event.Message != nil &&
event.Message.Role == codersdk.ChatMessageRoleUser &&
hasTextPart(event.Message.Content, initialMessage) {
foundInitialUserMessage = true
}
}
}
})
t.Run("AfterID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "stream chat after_id cursor"},
},
})
require.NoError(t, err)
page, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
require.NotEmpty(t, page.Messages)
afterID := page.Messages[0].ID
events, closer, err := client.StreamChat(ctx, chat.ID, &codersdk.StreamChatOptions{AfterID: &afterID})
require.NoError(t, err)
defer closer.Close()
snapshot := readStreamChatSnapshot(ctx, t, events)
require.Empty(t, streamChatEventsOfType(snapshot, codersdk.ChatStreamEventTypeHistoryReset))
for _, event := range streamChatEventsOfType(snapshot, codersdk.ChatStreamEventTypeMessage) {
require.Greater(t, event.Message.ID, afterID)
}
})
t.Run("AfterIDEditTruncation", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "before edit"},
},
})
require.NoError(t, err)
page, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
require.NotEmpty(t, page.Messages)
edited, err := client.EditChatMessage(ctx, chat.ID, page.Messages[0].ID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "after edit"},
},
})
require.NoError(t, err)
afterID := edited.Message.ID
events, closer, err := client.StreamChat(ctx, chat.ID, &codersdk.StreamChatOptions{AfterID: &afterID})
require.NoError(t, err)
defer closer.Close()
snapshot := readStreamChatSnapshot(ctx, t, events)
require.Empty(t, streamChatEventsOfType(snapshot, codersdk.ChatStreamEventTypeHistoryReset))
for _, event := range streamChatEventsOfType(snapshot, codersdk.ChatStreamEventTypeMessage) {
require.Greater(t, event.Message.ID, afterID)
}
})
t.Run("AfterIDUnknown", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "stream chat unknown cursor"},
},
})
require.NoError(t, err)
afterID := int64(1 << 40)
events, closer, err := client.StreamChat(ctx, chat.ID, &codersdk.StreamChatOptions{AfterID: &afterID})
require.NoError(t, err)
defer closer.Close()
snapshot := readStreamChatSnapshot(ctx, t, events)
require.Empty(t, streamChatEventsOfType(snapshot, codersdk.ChatStreamEventTypeHistoryReset))
for _, event := range streamChatEventsOfType(snapshot, codersdk.ChatStreamEventTypeMessage) {
require.Greater(t, event.Message.ID, afterID)
}
})
t.Run("AfterIDOtherChat", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
const initialMessage = "stream chat own history"
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: initialMessage},
},
})
require.NoError(t, err)
// Created second so the other chat's message ID is higher than this chat's.
const otherMessage = "stream chat other chat cursor"
other, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: otherMessage},
},
})
require.NoError(t, err)
otherPage, err := client.GetChatMessages(ctx, other.ID, nil)
require.NoError(t, err)
require.NotEmpty(t, otherPage.Messages)
foreignID := otherPage.Messages[0].ID
requireFullHistory := func(msg string) {
t.Helper()
events, closer, err := client.StreamChat(ctx, chat.ID, &codersdk.StreamChatOptions{AfterID: &foreignID})
require.NoError(t, err)
defer closer.Close()
snapshot := readStreamChatSnapshot(ctx, t, events)
require.Empty(t, streamChatEventsOfType(snapshot, codersdk.ChatStreamEventTypeHistoryReset))
require.True(t, streamChatSnapshotHasText(snapshot, initialMessage), msg)
require.False(t, streamChatSnapshotHasText(snapshot, otherMessage), "cursor from another chat must not leak that chat's messages")
for _, event := range snapshot {
require.Equal(t, chat.ID, event.ChatID)
}
}
requireFullHistory("cursor from another chat must fall back to the full history")
// The edit soft-deletes the cursor, which must still resolve to the other chat.
_, err = client.EditChatMessage(ctx, other.ID, foreignID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "stream chat other chat edited"},
},
})
require.NoError(t, err)
requireFullHistory("deleted cursor from another chat must fall back to the full history")
})
t.Run("EditedChatSyncsOnlyChangedHistory", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: "first prompt"}},
})
require.NoError(t, err)
waitForChatStatus(ctx, t, client, chat.ID, codersdk.ChatStatusWaiting)
_ = sendChatMessage(ctx, t, client, chat.ID, "second prompt")
newestPage := func() codersdk.ChatMessagesResponse {
t.Helper()
page, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
require.False(t, page.HasMore)
return page
}
lastPromptID := func(page codersdk.ChatMessagesResponse) int64 {
t.Helper()
var id int64
for _, m := range page.Messages {
if m.Role == codersdk.ChatMessageRoleUser {
id = max(id, m.ID)
}
}
require.NotZero(t, id)
return id
}
edit := func(messageID int64, text string) {
t.Helper()
resp, err := client.EditChatMessage(ctx, chat.ID, messageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: text}},
})
require.NoError(t, err)
require.NotEmpty(t, resp.DeletedMessageIDs)
}
requireResetFrom := func(events []codersdk.ChatStreamEvent, fromID int64) {
t.Helper()
resets := 0
for _, event := range events {
switch event.Type {
case codersdk.ChatStreamEventTypeHistoryReset:
resets++
require.NotNil(t, event.HistoryReset, "the reset replaced the whole history")
require.Equal(t, fromID, event.HistoryReset.FromMessageID)
require.Positive(t, event.SnapshotVersion)
case codersdk.ChatStreamEventTypeMessage:
require.GreaterOrEqual(t, event.Message.ID, fromID, "a message below the edit was resent")
require.Positive(t, event.SnapshotVersion)
}
}
require.Equal(t, 1, resets)
}
// A stream opened at a snapshot version resends the messages written
// at that version or later, which the tab already has.
requireOnlyResent := func(held []int64, events []codersdk.ChatStreamEvent) {
t.Helper()
for _, event := range events {
require.NotEqual(t, codersdk.ChatStreamEventTypeHistoryReset, event.Type, "the stream reset the history")
if event.Message != nil {
require.Contains(t, held, event.Message.ID, "the stream sent a message the tab did not hold")
}
}
}
// Opening a chat edited earlier must not reset the history, even though
// the rows the edit soft-deleted are still in the chat.
edit(lastPromptID(newestPage()), "edited once")
waitForChatStatus(ctx, t, client, chat.ID, codersdk.ChatStatusWaiting)
page := newestPage()
live := newChatTab(page)
pageIDs := live.sortedIDs()
applied, events := live.connect(ctx, t, client, chat.ID)
requireOnlyResent(pageIDs, applied)
// An edit while the stream is open resets the history from the
// edited message.
stale := newChatTab(page)
editedID := lastPromptID(page)
edit(editedID, "edited twice")
waitForChatStatus(ctx, t, client, chat.ID, codersdk.ChatStatusWaiting)
wantIDs := liveChatMessageIDs(ctx, t, client, chat.ID)
applied = live.applyUntil(ctx, t, events, func(codersdk.ChatStreamEvent) bool {
return slices.Equal(wantIDs, live.sortedIDs())
})
requireResetFrom(applied, editedID)
// Reconnecting with the highest snapshot version the tab received
// does not reset the history again.
applied, _ = live.connect(ctx, t, client, chat.ID)
requireOnlyResent(wantIDs, applied)
// A tab that missed the edit and then sent a message holds both the
// deleted messages and a newer message ID. Its reconnect must still
// reset the history from the edited message.
stale.hold(sendChatMessage(ctx, t, client, chat.ID, "sent while the stream was down")...)
applied, _ = stale.connect(ctx, t, client, chat.ID)
requireResetFrom(applied, editedID)
require.Equal(t, liveChatMessageIDs(ctx, t, client, chat.ID), stale.sortedIDs(), "the tab still shows deleted messages or is missing their replacements")
// A client without a snapshot version that holds message after_id
// gets no history reset, and no event includes snapshot_version.
legacy := newChatTab(newestPage())
legacy.withoutSnapshotVersion = true
applied, _ = legacy.connect(ctx, t, client, chat.ID)
for _, event := range applied {
require.NotEqual(t, codersdk.ChatStreamEventTypeHistoryReset, event.Type, "a client that holds message after_id got a history reset")
require.Zero(t, event.SnapshotVersion, "a %s event includes snapshot_version on a stream opened without it", event.Type)
}
require.Equal(t, liveChatMessageIDs(ctx, t, client, chat.ID), legacy.sortedIDs())
})
t.Run("ReconnectReceivesMessagesSentElsewhere", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: "first prompt"}},
})
require.NoError(t, err)
waitForChatStatus(ctx, t, client, chat.ID, codersdk.ChatStatusWaiting)
page, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
tab := newChatTab(page)
_, _ = tab.connect(ctx, t, client, chat.ID)
// While this tab is not reading its stream, another tab sends a message
// and then this tab sends one and holds it. The other tab's message
// has the lower ID, so after_id alone would skip it.
_ = sendChatMessage(ctx, t, client, chat.ID, "from another tab")
tab.hold(sendChatMessage(ctx, t, client, chat.ID, "from this tab")...)
_, _ = tab.connect(ctx, t, client, chat.ID)
require.Equal(t, liveChatMessageIDs(ctx, t, client, chat.ID), tab.sortedIDs(), "the tab is missing messages sent while it was not reading its stream")
})
// The web client does not refetch the messages after a clear or after a
// queued message is deleted, so the stream must deliver both.
t.Run("ClearSyncsOverStream", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: "prompt"}},
})
require.NoError(t, err)
waitForChatStatus(ctx, t, client, chat.ID, codersdk.ChatStatusWaiting)
page, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
tab := newChatTab(page)
_, events := tab.connect(ctx, t, client, chat.ID)
held := tab.sortedIDs()
_, err = client.ClearChat(ctx, chat.ID)
require.NoError(t, err)
live := liveChatMessageIDs(ctx, t, client, chat.ID)
require.NotEqual(t, held, live, "the clear changes the visible messages")
tab.applyUntil(ctx, t, events, func(codersdk.ChatStreamEvent) bool {
return slices.Equal(tab.sortedIDs(), live)
})
})
t.Run("DeleteQueuedSyncsOverStream", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "delete queued over stream",
Status: database.ChatStatusError,
})
content, err := json.Marshal([]codersdk.ChatMessagePart{codersdk.ChatMessageText("queued")})
require.NoError(t, err)
deleted := insertTestChatQueuedMessage(ctx, t, db, chat.ID, content, modelConfig.ID)
kept := insertTestChatQueuedMessage(ctx, t, db, chat.ID, content, modelConfig.ID)
page, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
tab := newChatTab(page)
_, events := tab.connect(ctx, t, client, chat.ID)
res, err := client.Request(ctx, http.MethodDelete, fmt.Sprintf("/api/v2/chats/%s/queue/%d", chat.ID, deleted.ID), nil)
require.NoError(t, err)
res.Body.Close()
require.Equal(t, http.StatusNoContent, res.StatusCode)
tab.applyUntil(ctx, t, events, func(event codersdk.ChatStreamEvent) bool {
return event.Type == codersdk.ChatStreamEventTypeQueueUpdate &&
len(event.QueuedMessages) == 1 && event.QueuedMessages[0].ID == kept.ID
})
})
t.Run("InvalidSnapshotVersionReturns400", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: "prompt"}},
})
require.NoError(t, err)
for _, version := range []string{"0", "-1", "abc"} {
res, err := client.Request(
ctx,
http.MethodGet,
fmt.Sprintf("/api/v2/chats/%s/stream?snapshot_version=%s", chat.ID, version),
nil,
)
require.NoError(t, err)
_ = res.Body.Close()
require.Equal(t, http.StatusBadRequest, res.StatusCode, "snapshot_version=%s", version)
}
})
t.Run("SnapshotVersionAboveChatReturns400", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: "prompt"}},
})
require.NoError(t, err)
page, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
res, err := client.Request(
ctx,
http.MethodGet,
fmt.Sprintf("/api/v2/chats/%s/stream?snapshot_version=%d", chat.ID, page.SnapshotVersion+100),
nil,
)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusBadRequest, res.StatusCode)
})
// A failed setup is an HTTP error before the upgrade, not an error
// event a client would show as the chat's state.
t.Run("SetupFailureReturnsHTTPError", func(t *testing.T) {
t.Parallel()
for _, tt := range []struct {
name string
failRead bool
failSubscribe bool
}{
{name: "ReadFails", failRead: true},
{name: "SubscribeFails", failSubscribe: true},
} {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, rawPS := dbtestutil.NewDB(t)
store := &chatStreamReadFailStore{Store: rawDB, fail: &atomic.Pointer[chatStreamReadFailure]{}}
ps := &chatStreamSubscribeFailPubsub{Pubsub: rawPS}
client := newChatClient(t, withChatWorkerDisabled, func(opts *coderdtest.Options) {
opts.Database = store
opts.Pubsub = ps
})
user := coderdtest.CreateFirstUser(t, client.Client)
model := createChatModel(t, client)
chat := dbgen.Chat(t, rawDB, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: model.ID,
Title: "stream setup failure",
Status: database.ChatStatusWaiting,
})
if tt.failRead {
store.fail.Store(&chatStreamReadFailure{chatID: chat.ID, err: xerrors.New("read failed")})
}
if tt.failSubscribe {
event := coderdpubsub.ChatStateUpdateChannel(chat.ID)
ps.failEvent.Store(&event)
}
u, err := client.URL.Parse(fmt.Sprintf("/api/v2/chats/%s/stream", chat.ID))
require.NoError(t, err)
conn, res, err := websocket.Dial(ctx, u.String(), &websocket.DialOptions{
HTTPHeader: http.Header{codersdk.SessionTokenHeader: {client.SessionToken()}},
})
if conn != nil {
_ = conn.Close(websocket.StatusNormalClosure, "")
}
require.Error(t, err, "the stream upgraded despite the failed setup")
require.NotNil(t, res)
if res.Body != nil {
_ = res.Body.Close()
}
require.Equal(t, http.StatusInternalServerError, res.StatusCode)
})
}
})
t.Run("Unauthenticated", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
unauthenticatedClient := codersdk.New(client.URL)
res, err := unauthenticatedClient.Request(
ctx,
http.MethodGet,
fmt.Sprintf("/api/v2/chats/%s/stream", uuid.New()),
nil,
)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusUnauthorized, res.StatusCode)
})
}
// TestChatOpenAIResponsesWebSearch runs provider-executed OpenAI web
// searches through the chat API and the AI Gateway daemon, then checks the
// streamed parts and the reloaded messages the chat UI renders, and what
// the next turn sends the model about the search.
func TestChatOpenAIResponsesWebSearch(t *testing.T) {
t.Parallel()
const answer = "Tokyo has about 14 million residents."
const followUpPrompt = "And Osaka?"
const followUpAnswer = "Osaka has about 2.7 million residents."
found := []string{"https://www.metro.tokyo.lg.jp/", "https://example.com/tokyo"}
// Live OpenAI streams add pages the answer cited to the search's
// sources only in response.completed; they are not found pages.
cited := []string{"https://example.com/cited"}
tests := []struct {
name string
store *bool
webSearch chattest.OpenAIWebSearchCall
wantArgs string
wantResult string
wantError bool
wantFound []string
// wantReplay is the web_search_call input item the next turn
// sends. gpt-4o produces no reasoning, so stored searches cannot
// go back as item references and replay inline too.
wantReplay string
}{
{
name: "QueriesAndSources",
webSearch: chattest.OpenAIWebSearchCall{
Queries: []string{"tokyo population", "tokyo census 2025"},
Query: "tokyo population",
},
wantArgs: `{"type":"search","queries":["tokyo population","tokyo census 2025"]}`,
wantResult: `{}`,
wantFound: found,
wantReplay: `{"type":"web_search_call","status":"completed","action":{"type":"search","queries":["tokyo population","tokyo census 2025"],"query":"tokyo population"}}`,
},
{
name: "Failed",
webSearch: chattest.OpenAIWebSearchCall{
Queries: []string{"tokyo population"},
Status: "failed",
},
wantArgs: `{"type":"search","queries":["tokyo population"]}`,
wantResult: `{"error":"web search failed"}`,
wantError: true,
wantReplay: `{"type":"web_search_call","status":"failed","action":{"type":"search","queries":["tokyo population"]}}`,
},
{
name: "UnstoredQueriesAndSources",
store: ptr.Ref(false),
webSearch: chattest.OpenAIWebSearchCall{
Queries: []string{"tokyo population", "tokyo census 2025"},
Query: "tokyo population",
},
wantArgs: `{"type":"search","queries":["tokyo population","tokyo census 2025"]}`,
wantResult: `{}`,
wantFound: found,
wantReplay: `{"type":"web_search_call","status":"completed","action":{"type":"search","queries":["tokyo population","tokyo census 2025"],"query":"tokyo population"}}`,
},
{
name: "UnstoredOpenPage",
store: ptr.Ref(false),
webSearch: chattest.OpenAIWebSearchCall{
ActionType: "open_page",
URL: "https://www.metro.tokyo.lg.jp/",
},
wantArgs: `{"type":"open_page","url":"https://www.metro.tokyo.lg.jp/"}`,
wantResult: `{}`,
wantReplay: `{"type":"web_search_call","status":"completed","action":{"type":"open_page","url":"https://www.metro.tokyo.lg.jp/"}}`,
},
{
name: "UnstoredFindInPage",
store: ptr.Ref(false),
webSearch: chattest.OpenAIWebSearchCall{
ActionType: "find_in_page",
URL: "https://www.metro.tokyo.lg.jp/",
Pattern: "population",
},
wantArgs: `{"type":"find_in_page","url":"https://www.metro.tokyo.lg.jp/","pattern":"population"}`,
wantResult: `{}`,
wantReplay: `{"type":"web_search_call","status":"completed","action":{"type":"find_in_page","url":"https://www.metro.tokyo.lg.jp/","pattern":"population"}}`,
},
{
name: "UnstoredFailed",
store: ptr.Ref(false),
webSearch: chattest.OpenAIWebSearchCall{
Queries: []string{"tokyo population"},
Status: "failed",
},
wantArgs: `{"type":"search","queries":["tokyo population"]}`,
wantResult: `{"error":"web search failed"}`,
wantError: true,
wantReplay: `{"type":"web_search_call","status":"failed","action":{"type":"search","queries":["tokyo population"]}}`,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
webSearchID := "ws_" + strings.ReplaceAll(uuid.NewString(), "-", "")
// The model turn waits until the test subscribes to the chat
// stream so the streamed parts cannot be missed.
streamReady := make(chan struct{})
var requestIncludes atomic.Pointer[[]string]
followUpBody := make(chan []byte, 1)
baseURL := chattest.NewOpenAI(t, func(req *chattest.OpenAIRequest) chattest.OpenAIResponse {
if !req.Stream {
return chattest.OpenAINonStreamingResponse(`{"title": "Tokyo population"}`)
}
if bytes.Contains(req.RawBody, []byte(followUpPrompt)) {
select {
case followUpBody <- req.RawBody:
default:
}
return chattest.OpenAIStreamingResponse(chattest.OpenAITextChunks(followUpAnswer)...)
}
var body struct {
Include []string `json:"include"`
}
if err := json.Unmarshal(req.RawBody, &body); err == nil {
requestIncludes.Store(&body.Include)
}
select {
case <-streamReady:
case <-req.Context().Done():
}
resp := chattest.OpenAIStreamingResponse(chattest.OpenAITextChunks(answer)...)
webSearch := tt.webSearch
webSearch.ID = webSearchID
webSearch.Sources = tt.wantFound
webSearch.SummaryOnlySources = cited
resp.WebSearch = &webSearch
return resp
})
client, _, api := newChatClientWithoutAIBridge(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
provider, err := client.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeOpenAI,
Name: "test-openai-" + uuid.NewString(),
BaseURL: baseURL,
Enabled: true,
APIKeys: []string{coderdtest.TestChatProviderAPIKey},
})
require.NoError(t, err)
_, err = client.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &provider.ID,
Model: "gpt-4o",
ContextLimit: ptr.Ref(int64(128000)),
IsDefault: ptr.Ref(true),
ModelConfig: &codersdk.ChatModelCallConfig{
OpenAIConfig: &codersdk.ChatModelOpenAIConfig{UseResponsesAPI: ptr.Ref(true)},
ProviderOptions: &codersdk.ChatModelProviderOptions{
OpenAI: &codersdk.ChatModelOpenAIProviderOptions{
WebSearchEnabled: ptr.Ref(true),
Store: tt.store,
},
},
},
})
require.NoError(t, err)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "How many people live in Tokyo?",
}},
})
require.NoError(t, err)
events, closer, err := client.StreamChat(ctx, chat.ID, nil)
require.NoError(t, err)
defer closer.Close()
close(streamReady)
// requireWebSearchParts checks what the UI renders for the
// search: the call with its action, the result that finishes
// it, and its found pages as sources tagged with the search.
requireWebSearchParts := func(t *testing.T, call, result *codersdk.ChatMessagePart, foundURLs []string) {
t.Helper()
require.NotNil(t, call, "missing web_search tool-call part")
require.True(t, call.ProviderExecuted)
require.JSONEq(t, tt.wantArgs, string(call.Args))
require.NotNil(t, result, "missing web_search tool-result part")
require.True(t, result.ProviderExecuted)
require.Equal(t, tt.wantError, result.IsError)
require.JSONEq(t, tt.wantResult, string(result.Result))
require.Equal(t, tt.wantFound, foundURLs)
}
isWebSearchPart := func(part codersdk.ChatMessagePart, partType codersdk.ChatMessagePartType) bool {
return part.Type == partType && part.ToolName == "web_search" && part.ToolCallID == webSearchID
}
foundURL := func(t *testing.T, part codersdk.ChatMessagePart) (string, bool) {
t.Helper()
if part.Type != codersdk.ChatMessagePartTypeSource {
return "", false
}
require.Equal(t, webSearchID, part.ToolCallID, "source %q should be tagged with the search", part.URL)
require.NotContains(t, cited, part.URL, "a cited page must not become a found page")
return part.URL, true
}
var streamedCall, streamedResult *codersdk.ChatMessagePart
var streamedFound []string
for streamedResult == nil {
select {
case <-ctx.Done():
require.FailNow(t, "timed out waiting for the streamed web_search result")
case event, ok := <-events:
require.True(t, ok, "stream closed before the web_search result")
require.NotEqual(t, codersdk.ChatStreamEventTypeError, event.Type)
if event.Type != codersdk.ChatStreamEventTypeMessagePart || event.MessagePart == nil {
continue
}
part := event.MessagePart.Part
if url, ok := foundURL(t, part); ok {
streamedFound = append(streamedFound, url)
}
switch {
case isWebSearchPart(part, codersdk.ChatMessagePartTypeToolCall):
streamedCall = &part
case isWebSearchPart(part, codersdk.ChatMessagePartTypeToolResult):
streamedResult = &part
}
}
}
// The search's found pages arrive before its result.
requireWebSearchParts(t, streamedCall, streamedResult, streamedFound)
settled := coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
require.Equal(t, database.ChatStatusWaiting, settled.Status)
includes := requestIncludes.Load()
require.NotNil(t, includes, "the provider did not receive the streaming request")
require.Contains(t, *includes, "web_search_call.action.sources")
// Reloading the conversation reads the persisted rows.
messages, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var reloadedCall, reloadedResult *codersdk.ChatMessagePart
var reloadedFound []string
var reloadedText string
for _, message := range messages.Messages {
if message.Role != codersdk.ChatMessageRoleAssistant {
continue
}
for _, part := range message.Content {
require.Empty(t, part.ProviderMetadata, "API responses must strip provider metadata")
if url, ok := foundURL(t, part); ok {
reloadedFound = append(reloadedFound, url)
}
switch {
case isWebSearchPart(part, codersdk.ChatMessagePartTypeToolCall):
reloadedCall = &part
case isWebSearchPart(part, codersdk.ChatMessagePartTypeToolResult):
reloadedResult = &part
case part.Type == codersdk.ChatMessagePartTypeText:
reloadedText += part.Text
}
}
}
requireWebSearchParts(t, reloadedCall, reloadedResult, reloadedFound)
require.Equal(t, answer, reloadedText)
// The next turn builds its prompt from the saved history.
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: followUpPrompt,
}},
})
require.NoError(t, err)
// The fake server rejects an invalid request before the
// handler sees it, so the chat's error is the only signal.
var rawFollowUp []byte
for rawFollowUp == nil {
select {
case <-ctx.Done():
require.FailNow(t, "timed out waiting for the follow-up request")
case rawFollowUp = <-followUpBody:
case event, ok := <-events:
require.True(t, ok, "stream closed before the follow-up request")
if event.Type == codersdk.ChatStreamEventTypeError {
require.FailNowf(t, "follow-up turn failed", "%+v", event.Error)
}
}
}
settled = coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
require.Equal(t, database.ChatStatusWaiting, settled.Status)
var followUp struct {
Store *bool `json:"store"`
Input []json.RawMessage `json:"input"`
}
require.NoError(t, json.Unmarshal(rawFollowUp, &followUp))
require.NotNil(t, followUp.Store)
require.Equal(t, tt.store == nil || *tt.store, *followUp.Store)
var inputKinds []string
var replayed json.RawMessage
for _, raw := range followUp.Input {
var item struct {
Type string `json:"type"`
Role string `json:"role"`
}
require.NoError(t, json.Unmarshal(raw, &item))
switch {
case item.Role == "system" || item.Role == "developer":
continue
case item.Type == "web_search_call":
replayed = raw
}
if item.Role != "" {
inputKinds = append(inputKinds, item.Role)
} else {
inputKinds = append(inputKinds, item.Type)
}
}
require.Equal(t, []string{"user", "web_search_call", "assistant", "user"}, inputKinds)
require.JSONEq(t, tt.wantReplay, string(replayed))
})
}
}
func TestInterruptChat(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "interrupt route test",
})
runningWorkerID := uuid.New()
var err error
chat, err = db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusRunning,
WorkerID: uuid.NullUUID{UUID: runningWorkerID, Valid: true},
StartedAt: sql.NullTime{Time: time.Now(), Valid: true},
HeartbeatAt: sql.NullTime{Time: time.Now(), Valid: true},
})
require.NoError(t, err)
require.Equal(t, database.ChatStatusRunning, chat.Status)
require.True(t, chat.WorkerID.Valid)
require.True(t, chat.StartedAt.Valid)
require.True(t, chat.HeartbeatAt.Valid)
interrupted, err := client.InterruptChat(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, chat.ID, interrupted.ID)
require.Equal(t, codersdk.ChatStatusInterrupting, interrupted.Status)
persisted, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, database.ChatStatusInterrupting, persisted.Status)
require.True(t, persisted.WorkerID.Valid)
require.True(t, persisted.StartedAt.Valid)
require.True(t, persisted.HeartbeatAt.Valid)
})
t.Run("ChatNotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
_, err := client.InterruptChat(ctx, uuid.New())
requireSDKError(t, err, http.StatusNotFound)
})
}
func TestCompactChat(t *testing.T) {
t.Parallel()
// seedCompactableChat inserts an idle chat with one user and one
// assistant message so a manual compaction has something to
// summarize.
seedCompactableChat := func(t *testing.T, db database.Store, orgID, ownerID, modelConfigID uuid.UUID) database.Chat {
t.Helper()
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: orgID,
OwnerID: ownerID,
LastModelConfigID: modelConfigID,
Title: "compact route test",
})
userContent, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("question"),
})
require.NoError(t, err)
_ = dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
CreatedBy: uuid.NullUUID{UUID: ownerID, Valid: true},
ModelConfigID: uuid.NullUUID{UUID: modelConfigID, Valid: true},
Role: database.ChatMessageRoleUser,
Content: userContent,
})
assistantContent, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("answer"),
})
require.NoError(t, err)
_ = dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
ModelConfigID: uuid.NullUUID{UUID: modelConfigID, Valid: true},
Role: database.ChatMessageRoleAssistant,
Content: assistantContent,
})
return chat
}
t.Run("RequestsCompaction", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := seedCompactableChat(t, db, user.OrganizationID, user.UserID, modelConfig.ID)
// Assert on the response snapshot only: the chat is runnable
// after the transition, so a worker may already be mutating
// the persisted row.
compacted, err := client.CompactChat(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, chat.ID, compacted.ID)
require.Equal(t, codersdk.ChatStatusRunning, compacted.Status)
})
t.Run("NothingToCompact", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Idle chat with only a user message: no assistant turn to
// summarize.
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "compact empty test",
})
userContent, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("question"),
})
require.NoError(t, err)
_ = dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
CreatedBy: uuid.NullUUID{UUID: user.UserID, Valid: true},
ModelConfigID: uuid.NullUUID{UUID: modelConfig.ID, Valid: true},
Role: database.ChatMessageRoleUser,
Content: userContent,
})
_, err = client.CompactChat(ctx, chat.ID)
sdkErr := requireSDKError(t, err, http.StatusConflict)
require.Contains(t, sdkErr.Message, "Nothing to compact")
persisted, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, database.ChatStatusWaiting, persisted.Status)
require.False(t, persisted.CompactionRequestedAt.Valid)
})
t.Run("FromErrorState", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := seedCompactableChat(t, db, user.OrganizationID, user.UserID, modelConfig.ID)
_, err := db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusError,
LastError: pqtype.NullRawMessage{
RawMessage: json.RawMessage(`{"message":"context overflow"}`),
Valid: true,
},
})
require.NoError(t, err)
// Response snapshot only: a worker may already be mutating
// the persisted row.
compacted, err := client.CompactChat(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, chat.ID, compacted.ID)
require.Equal(t, codersdk.ChatStatusRunning, compacted.Status)
require.Nil(t, compacted.LastError,
"compaction from the error state clears last_error")
})
t.Run("Busy", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := seedCompactableChat(t, db, user.OrganizationID, user.UserID, modelConfig.ID)
_, err := db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusRunning,
WorkerID: uuid.NullUUID{UUID: uuid.New(), Valid: true},
StartedAt: sql.NullTime{Time: time.Now(), Valid: true},
HeartbeatAt: sql.NullTime{Time: time.Now(), Valid: true},
})
require.NoError(t, err)
_, err = client.CompactChat(ctx, chat.ID)
sdkErr := requireSDKError(t, err, http.StatusConflict)
require.Contains(t, sdkErr.Message, "Cannot compact the chat in its current state")
require.Contains(t, sdkErr.Detail, "Compaction is available only while the chat is waiting or errored.")
})
t.Run("Archived", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := seedCompactableChat(t, db, user.OrganizationID, user.UserID, modelConfig.ID)
_, err := db.ArchiveChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
_, err = client.CompactChat(ctx, chat.ID)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "archived")
})
t.Run("ChatNotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
_, err := client.CompactChat(ctx, uuid.New())
requireSDKError(t, err, http.StatusNotFound)
})
// Even the owner needs RBAC update permission on the chat.
t.Run("UpdateDenied", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
clientRaw, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
Authorizer: &coderdtest.FakeAuthorizer{
ConditionalReturn: func(_ context.Context, subject rbac.Subject, action policy.Action, object rbac.Object) error {
// dbgen seeds rows with a synthetic "owner" subject;
// message inserts need chat update, so let them pass.
if subject.ID == "owner" {
return nil
}
if action == policy.ActionUpdate && object.Type == rbac.ResourceChat.Type {
return xerrors.New("denied")
}
return nil
},
},
DeploymentValues: coderdtest.DeploymentValues(t),
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
db := api.Database
client := codersdk.NewExperimentalClient(clientRaw)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := seedCompactableChat(t, db, user.OrganizationID, user.UserID, modelConfig.ID)
_, err := client.CompactChat(ctx, chat.ID)
requireSDKError(t, err, http.StatusNotFound)
})
}
func TestClearChat(t *testing.T) {
t.Parallel()
messageText := func(t *testing.T, msg database.ChatMessage) string {
t.Helper()
parts, err := chatprompt.ParseContent(msg)
require.NoError(t, err)
var builder strings.Builder
for _, part := range parts {
if part.Type == codersdk.ChatMessagePartTypeText {
_, _ = builder.WriteString(part.Text)
}
}
return builder.String()
}
// seedClearableChat inserts an idle chat with one user and one
// assistant message so a manual clear has conversation to cut off.
seedClearableChat := func(t *testing.T, db database.Store, orgID, ownerID, modelConfigID uuid.UUID) database.Chat {
t.Helper()
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: orgID,
OwnerID: ownerID,
LastModelConfigID: modelConfigID,
Title: "clear route test",
})
userContent, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("question"),
})
require.NoError(t, err)
_ = dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
CreatedBy: uuid.NullUUID{UUID: ownerID, Valid: true},
ModelConfigID: uuid.NullUUID{UUID: modelConfigID, Valid: true},
Role: database.ChatMessageRoleUser,
Content: userContent,
})
assistantContent, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("answer"),
})
require.NoError(t, err)
_ = dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
ModelConfigID: uuid.NullUUID{UUID: modelConfigID, Valid: true},
Role: database.ChatMessageRoleAssistant,
Content: assistantContent,
})
return chat
}
t.Run("ClearsContext", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := seedClearableChat(t, db, user.OrganizationID, user.UserID, modelConfig.ID)
// The clear commits synchronously, so the chat stays idle and
// persisted state can be asserted without racing a worker.
cleared, err := client.ClearChat(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, chat.ID, cleared.ID)
require.Equal(t, codersdk.ChatStatusWaiting, cleared.Status)
persisted, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, database.ChatStatusWaiting, persisted.Status)
prompt, err := db.GetChatMessagesForPromptByChatID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
for _, msg := range prompt {
text := messageText(t, msg)
require.NotContains(t, text, "question",
"pre-clear conversation must not survive in the prompt")
require.NotContains(t, text, "answer",
"pre-clear conversation must not survive in the prompt")
}
_, err = client.ClearChat(ctx, chat.ID)
sdkErr := requireSDKError(t, err, http.StatusConflict)
require.Contains(t, sdkErr.Message, "Nothing to clear")
_, err = client.CompactChat(ctx, chat.ID)
sdkErr = requireSDKError(t, err, http.StatusConflict)
require.Contains(t, sdkErr.Message, "Nothing to compact")
})
t.Run("NothingToClear", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "clear empty test",
})
_, err := client.ClearChat(ctx, chat.ID)
sdkErr := requireSDKError(t, err, http.StatusConflict)
require.Contains(t, sdkErr.Message, "Nothing to clear")
persisted, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, database.ChatStatusWaiting, persisted.Status)
})
t.Run("FromErrorState", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := seedClearableChat(t, db, user.OrganizationID, user.UserID, modelConfig.ID)
_, err := db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusError,
LastError: pqtype.NullRawMessage{
RawMessage: json.RawMessage(`{"message":"context overflow"}`),
Valid: true,
},
})
require.NoError(t, err)
cleared, err := client.ClearChat(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, chat.ID, cleared.ID)
require.Equal(t, codersdk.ChatStatusWaiting, cleared.Status)
require.Nil(t, cleared.LastError,
"clearing from the error state clears last_error")
})
t.Run("Busy", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := seedClearableChat(t, db, user.OrganizationID, user.UserID, modelConfig.ID)
_, err := db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusRunning,
WorkerID: uuid.NullUUID{UUID: uuid.New(), Valid: true},
StartedAt: sql.NullTime{Time: time.Now(), Valid: true},
HeartbeatAt: sql.NullTime{Time: time.Now(), Valid: true},
})
require.NoError(t, err)
_, err = client.ClearChat(ctx, chat.ID)
sdkErr := requireSDKError(t, err, http.StatusConflict)
require.Contains(t, sdkErr.Message, "Cannot clear the chat in its current state")
})
t.Run("ErrorWithQueue", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := seedClearableChat(t, db, user.OrganizationID, user.UserID, modelConfig.ID)
_, err := db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusError,
LastError: pqtype.NullRawMessage{
RawMessage: json.RawMessage(`{"message":"boom"}`),
Valid: true,
},
})
require.NoError(t, err)
queuedContent, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("queued follow-up"),
})
require.NoError(t, err)
_, err = db.InsertChatQueuedMessageWithCreator(dbauthz.AsSystemRestricted(ctx), database.InsertChatQueuedMessageWithCreatorParams{
ChatID: chat.ID,
Content: queuedContent.RawMessage,
CreatedBy: user.UserID,
BusyBehavior: database.ChatBusyBehaviorQueue,
})
require.NoError(t, err)
// No waiting-with-queue state exists, so a synchronous clear
// from E1 is rejected; the user deletes or promotes the queue
// first.
_, err = client.ClearChat(ctx, chat.ID)
sdkErr := requireSDKError(t, err, http.StatusConflict)
require.Contains(t, sdkErr.Message, "Cannot clear the chat in its current state")
})
t.Run("Archived", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := seedClearableChat(t, db, user.OrganizationID, user.UserID, modelConfig.ID)
_, err := db.ArchiveChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
_, err = client.ClearChat(ctx, chat.ID)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "archived")
})
t.Run("ChatNotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
_, err := client.ClearChat(ctx, uuid.New())
requireSDKError(t, err, http.StatusNotFound)
})
// Even the owner needs RBAC update permission on the chat.
t.Run("UpdateDenied", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
clientRaw, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
Authorizer: &coderdtest.FakeAuthorizer{
ConditionalReturn: func(_ context.Context, subject rbac.Subject, action policy.Action, object rbac.Object) error {
// dbgen seeds rows with a synthetic "owner" subject;
// message inserts need chat update, so let them pass.
if subject.ID == "owner" {
return nil
}
if action == policy.ActionUpdate && object.Type == rbac.ResourceChat.Type {
return xerrors.New("denied")
}
return nil
},
},
DeploymentValues: coderdtest.DeploymentValues(t),
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
db := api.Database
client := codersdk.NewExperimentalClient(clientRaw)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := seedClearableChat(t, db, user.OrganizationID, user.UserID, modelConfig.ID)
_, err := client.ClearChat(ctx, chat.ID)
requireSDKError(t, err, http.StatusNotFound)
})
}
func TestProposeChatTitle(t *testing.T) {
t.Parallel()
t.Run("ChatNotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
_, err := client.ProposeChatTitle(ctx, uuid.New())
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("UpdateDenied", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
clientRaw, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
Authorizer: &coderdtest.FakeAuthorizer{
ConditionalReturn: func(_ context.Context, _ rbac.Subject, action policy.Action, object rbac.Object) error {
if action == policy.ActionUpdate && object.Type == rbac.ResourceChat.Type {
return xerrors.New("denied")
}
return nil
},
},
DeploymentValues: coderdtest.DeploymentValues(t),
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
db := api.Database
client := codersdk.NewExperimentalClient(clientRaw)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "chat with update denied",
})
_, err := client.ProposeChatTitle(ctx, chat.ID)
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("Unauthenticated", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "chat for unauthenticated proposal",
}},
})
require.NoError(t, err)
unauthenticatedClient := codersdk.NewExperimentalClient(codersdk.New(client.URL))
_, err = unauthenticatedClient.ProposeChatTitle(ctx, chat.ID)
requireSDKError(t, err, http.StatusUnauthorized)
})
t.Run("PasteOnlyChat", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db, api := newChatClientWithoutAIBridge(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createTitleGenerationChatModel(t, client)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "New Chat",
Status: database.ChatStatusWaiting,
})
// The chat's only user message is a synthetic pasted-text
// attachment with no text parts.
seedPasteOnlyTitleSourceMessage(ctx, t, db, chat, modelConfig.ID, "pasted stack trace for title")
proposed, err := client.ProposeChatTitle(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, "Test Chat", proposed.Title)
})
t.Run("DoesNotBumpHistoryVersion", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db, api := newChatClientWithoutAIBridge(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createTitleGenerationChatModel(t, client)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "history fence chat",
})
seedManualTitleSourceMessage(t, db, chat, modelConfig.ID)
// Bump the snapshot version up front so the assertion below
// detects any further bump caused by the propose call.
_, err := db.LockChatAndBumpSnapshotVersion(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
before, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.NotEqual(t, before.SnapshotVersion, before.HistoryVersion,
"setup must leave history_version lagging snapshot_version")
resp, err := client.ProposeChatTitle(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, "Test Chat", resp.Title)
after, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, before.HistoryVersion, after.HistoryVersion,
"title proposal must not touch chat_messages")
})
t.Run("NoDefaultModelConfig", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
chat := seedChatWithDeletedModelConfig(ctx, t, db, user)
_, err := client.ProposeChatTitle(ctx, chat.ID)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "No chat model is available in this organization.", sdkErr.Message)
require.Equal(t, "Ask an organization administrator to configure and enable a chat model.", sdkErr.Detail)
})
t.Run("StoppedWorkspace", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db, api := newChatClientWithoutAIBridge(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createTitleGenerationChatModel(t, client)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
workspaceBuild := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
}).WithAgent().Do()
dbfake.WorkspaceBuild(t, db, workspaceBuild.Workspace).Seed(database.WorkspaceBuild{
Transition: database.WorkspaceTransitionStop,
BuildNumber: 2,
}).Do()
// Chats bound to stopped workspaces settle in waiting (or
// error). Title generation never touches the workspace, so it
// must still succeed.
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
WorkspaceID: uuid.NullUUID{UUID: workspaceBuild.Workspace.ID, Valid: true},
Status: database.ChatStatusWaiting,
Title: "stopped workspace chat",
})
seedManualTitleSourceMessage(t, db, chat, modelConfig.ID)
resp, err := client.ProposeChatTitle(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, "Test Chat", resp.Title)
})
t.Run("DoesNotPersistTitleOrBumpUpdatedAt", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db, api := newChatClientWithoutAIBridge(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModelWithTitleFailure(t, client)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "test chat"},
},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
before, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
_, err = client.ProposeChatTitle(ctx, chat.ID)
requireSDKError(t, err, http.StatusInternalServerError)
after, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, before.Title, after.Title,
"propose must not persist the suggested title")
require.True(t, after.UpdatedAt.Equal(before.UpdatedAt),
"propose must not bump updated_at")
})
t.Run("UsageLimitExhausted", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, _, api := newChatClientWithAPIAndDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModelWithTitleQuotaExhausted(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "test chat"},
},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
_, err = client.ProposeChatTitle(ctx, chat.ID)
sdkErr := requireSDKError(t, err, http.StatusConflict)
require.Equal(t,
"The AI usage limit has been exceeded. Contact an administrator or check the applicable budget and quota settings.",
sdkErr.Message)
})
}
func TestManualTitleEndpointsPassOwnerSyntheticAPIKeyToAIGateway(t *testing.T) {
t.Parallel()
for _, tt := range []struct {
name string
call func(context.Context, *codersdk.ExperimentalClient, uuid.UUID) error
}{
{
name: "ProposeChatTitle",
call: func(ctx context.Context, client *codersdk.ExperimentalClient, chatID uuid.UUID) error {
_, err := client.ProposeChatTitle(ctx, chatID)
return err
},
},
} {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
values := coderdtest.DeploymentValues(t)
require.NoError(t, values.AI.BridgeConfig.Enabled.Set("true"))
require.NoError(t, values.AI.Chat.AIGatewayRoutingEnabled.Set("true"))
client, db, api := newChatClientWithAPIAndDatabase(t, func(opts *coderdtest.Options) {
opts.DeploymentValues = values
})
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createAdditionalChatModel(t, client, "openai", "gpt-4.1")
wantTitle := "Fallback title"
seenAPIKeyID := make(chan string, 1)
stub := &stubTransportFactory{
handler: http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
apiKeyID, _ := aibridge.DelegatedAPIKeyIDFromContext(r.Context())
seenAPIKeyID <- apiKeyID
rw.Header().Set("Content-Type", "application/json")
text := strconv.Quote(`{"title":"` + wantTitle + `"}`)
_, _ = io.WriteString(rw, `{"id":"resp_test","object":"response","created_at":0,"status":"completed","model":"gpt-4.1","output":[{"id":"msg_test","type":"message","role":"assistant","content":[{"type":"output_text","text":`+text+`}]}],"usage":{"input_tokens":1,"output_tokens":1,"total_tokens":2}}`)
}),
calls: make(chan callRecord, 1),
}
var factory aibridge.TransportFactory = stub
api.AIBridgeTransportFactory.Store(&factory)
_, err := client.UpdateOrganizationChatModelOverride(ctx, firstUser.OrganizationID, codersdk.ChatModelOverrideContextTitleGeneration, codersdk.UpdateChatModelOverrideRequest{
ModelConfigID: modelConfig.ID.String(),
})
require.NoError(t, err)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "initial title",
Status: database.ChatStatusWaiting,
})
content, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("manual title source"),
})
require.NoError(t, err)
_ = dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
CreatedBy: uuid.NullUUID{UUID: firstUser.UserID, Valid: true},
ModelConfigID: uuid.NullUUID{UUID: modelConfig.ID, Valid: true},
Role: database.ChatMessageRoleUser,
Visibility: database.ChatMessageVisibilityBoth,
Content: content,
})
require.NoError(t, tt.call(ctx, client, chat.ID))
gatewayKey, err := db.GetChatGatewayAPIKey(dbauthz.AsSystemRestricted(ctx), database.GetChatGatewayAPIKeyParams{
UserID: firstUser.UserID,
TokenName: chatd.GatewayTokenName(firstUser.UserID),
})
require.NoError(t, err)
require.Equal(t, gatewayKey.ID, testutil.RequireReceive(ctx, t, seenAPIKeyID))
})
}
}
func TestPostChats_AutomaticTitleGeneration(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
// titleRequested is signaled when the provider receives the structured
// title-generation request. Automatic title generation issues a
// non-streaming request using the "propose_title" schema, which uniquely
// identifies it (the turn status label uses "propose_turn_status_label").
titleRequested := make(chan struct{}, 1)
baseURL := chattest.NewOpenAI(t, func(req *chattest.OpenAIRequest) chattest.OpenAIResponse {
if req.Stream {
return chattest.OpenAIStreamingResponse(chattest.OpenAITextChunks("Hello from test server.")...)
}
if bytes.Contains(req.RawBody, []byte("propose_title")) {
select {
case titleRequested <- struct{}{}:
default:
}
}
return chattest.OpenAINonStreamingResponse(`{"title": "Generated Title"}`)
})
client, _, api := newChatClientWithoutAIBridge(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModelWithBaseURL(t, client, baseURL)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "automatic title generation please",
}},
})
require.NoError(t, err)
// The create response carries the synchronous fallback title derived from
// the message, not the asynchronously generated one.
require.Equal(t, "automatic title generation please", chat.Title)
require.Equal(t, codersdk.ChatTitleSourceFallback, chat.TitleSource)
// The create endpoint kicks off detached title generation; the provider
// should receive the title request without any further client action.
select {
case <-titleRequested:
case <-ctx.Done():
t.Fatal("timed out waiting for automatic title generation to be triggered")
}
// Drain background work so the detached goroutine finishes before the test
// (and its fake provider) tears down.
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
}
func TestPostChats_UserTitle(t *testing.T) {
t.Parallel()
const prompt = "automatic title generation please"
ctx := testutil.Context(t, testutil.WaitLong)
baseURL := chattest.NewOpenAI(t, func(req *chattest.OpenAIRequest) chattest.OpenAIResponse {
if req.Stream {
return chattest.OpenAIStreamingResponse(chattest.OpenAITextChunks("Hello from test server.")...)
}
if bytes.Contains(req.RawBody, []byte("propose_title")) {
t.Error("automatic title generation ran for a chat created with a title")
}
return chattest.OpenAINonStreamingResponse(`{"title": "Generated Title"}`)
})
client, _, api := newChatClientWithoutAIBridge(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModelWithBaseURL(t, client, baseURL)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
// Title text is validated by the same rules as PATCH; see TestPatchChat/Title.
_, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Title: new(" "),
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: prompt}},
})
var sdkErr *codersdk.Error
require.ErrorAs(t, err, &sdkErr)
require.Equal(t, http.StatusBadRequest, sdkErr.StatusCode())
// Same text as the fallback, so only the source distinguishes them.
userTitle := chatprompt.FallbackTitle(prompt)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Title: new(" " + userTitle + " "),
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: prompt}},
})
require.NoError(t, err)
require.Equal(t, userTitle, chat.Title)
require.Equal(t, codersdk.ChatTitleSourceUser, chat.TitleSource)
settled := coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
require.Equal(t, userTitle, settled.Title)
require.Equal(t, database.ChatTitleSourceUser, settled.TitleSource)
}
func TestPostChats_AutomaticTitleGenerationPasteOnly(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
const pasteContent = "panic: runtime error: invalid memory address or nil pointer dereference"
// titleRequested is signaled when the provider receives a structured
// title-generation request whose input carries the pasted attachment
// content. Without paste-aware title input the request is never
// issued because the message has no text parts.
titleRequested := make(chan struct{}, 1)
baseURL := chattest.NewOpenAI(t, func(req *chattest.OpenAIRequest) chattest.OpenAIResponse {
if req.Stream {
return chattest.OpenAIStreamingResponse(chattest.OpenAITextChunks("Hello from test server.")...)
}
if bytes.Contains(req.RawBody, []byte("propose_title")) &&
bytes.Contains(req.RawBody, []byte("nil pointer dereference")) {
select {
case titleRequested <- struct{}{}:
default:
}
}
return chattest.OpenAINonStreamingResponse(`{"title": "Generated Title"}`)
})
client, _, api := newChatClientWithoutAIBridge(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModelWithBaseURL(t, client, baseURL)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
uploadResp, err := client.UploadChatFile(
ctx,
firstUser.OrganizationID,
"text/plain",
"pasted-text-2026-01-02-03-04-05.txt",
strings.NewReader(pasteContent),
)
require.NoError(t, err)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeFile,
FileID: uploadResp.ID,
}},
})
require.NoError(t, err)
// The create response carries the synchronous fallback title derived
// from the pasted attachment content.
require.Equal(t, pasteContent, chat.Title)
select {
case <-titleRequested:
case <-ctx.Done():
t.Fatal("timed out waiting for automatic title generation to be triggered")
}
// Drain background work so the detached goroutine finishes before the test
// (and its fake provider) tears down.
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
}
// TestPostChats_EmptyContent verifies chats can be created without an
// initial message. The chat starts idle in `waiting` with the
// placeholder title and only system messages, can be archived right
// away (the cleanup path for clients whose post-create work fails),
// and its first message inserts directly instead of queueing.
func TestPostChats_EmptyContent(t *testing.T) {
t.Parallel()
t.Run("CreateIdleThenFirstMessage", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
})
require.NoError(t, err)
require.Equal(t, codersdk.ChatStatusWaiting, chat.Status)
require.Equal(t, chatprompt.DefaultChatTitle, chat.Title)
messagesResp, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
for _, msg := range messagesResp.Messages {
require.NotEqual(t, codersdk.ChatMessageRoleUser, msg.Role, "an empty create must not insert a user message")
}
require.Empty(t, messagesResp.QueuedMessages)
// The chat is idle, so the first message inserts directly
// (W -> R0) rather than queueing behind a running turn.
messageResp, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: "hello"}},
})
require.NoError(t, err)
require.False(t, messageResp.Queued)
require.NotNil(t, messageResp.Message)
})
t.Run("ArchiveImmediately", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
})
require.NoError(t, err)
require.Equal(t, codersdk.ChatStatusWaiting, chat.Status)
// An idle chat archives without waiting for any generation,
// so clients can clean up when post-create work fails.
archived := true
err = client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{Archived: &archived})
require.NoError(t, err)
refreshed, err := client.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.True(t, refreshed.Archived)
})
}
// TestPostChatMessages_TitleGenerationForEmptyCreatedChat verifies
// that a chat created without an initial message gets its automatic
// title when the first message is posted instead of at create time.
func TestPostChatMessages_TitleGenerationForEmptyCreatedChat(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
titleRequested := make(chan struct{}, 1)
baseURL := chattest.NewOpenAI(t, func(req *chattest.OpenAIRequest) chattest.OpenAIResponse {
if req.Stream {
return chattest.OpenAIStreamingResponse(chattest.OpenAITextChunks("Hello from test server.")...)
}
if bytes.Contains(req.RawBody, []byte("propose_title")) {
select {
case titleRequested <- struct{}{}:
default:
}
}
return chattest.OpenAINonStreamingResponse(`{"title": "Generated Title"}`)
})
client, _, api := newChatClientWithoutAIBridge(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModelWithBaseURL(t, client, baseURL)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
})
require.NoError(t, err)
require.Equal(t, chatprompt.DefaultChatTitle, chat.Title, "empty creates carry the placeholder title")
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: "name this chat please"}},
})
require.NoError(t, err)
select {
case <-titleRequested:
case <-ctx.Done():
t.Fatal("timed out waiting for automatic title generation after the first message")
}
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
}
// TestPostChatMessages_FallbackTitleForEmptyCreatedChat verifies that
// the first message on an empty-created chat persists the fallback
// title even when automatic title generation fails.
func TestPostChatMessages_FallbackTitleForEmptyCreatedChat(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, _, api := newChatClientWithoutAIBridge(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModelWithTitleFailure(t, client)
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
})
require.NoError(t, err)
const text = "summarize the failing upload integration tests for me"
_, err = client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: text}},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
refreshed, err := client.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, chatprompt.FallbackTitle(text), refreshed.Title)
}
func TestGetChatDiffStatus(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
DeploymentValues: coderdtest.DeploymentValues(t),
ExternalAuthConfigs: []*externalauth.Config{
{
ID: "gitlab-test",
Type: "gitlab",
Regex: regexp.MustCompile(`github\.com`),
},
},
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
db := api.Database
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
noCachedStatusChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "get diff status route no cache",
})
noCachedChat, err := client.GetChat(ctx, noCachedStatusChat.ID)
require.NoError(t, err)
require.Equal(t, noCachedStatusChat.ID, noCachedChat.ID)
require.Nil(t, noCachedChat.DiffStatus)
cachedStatusChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "get diff status route cached",
})
refreshedAt := time.Now().UTC().Truncate(time.Second)
staleAt := refreshedAt.Add(time.Hour)
_, err = db.UpsertChatDiffStatusReference(
dbauthz.AsSystemRestricted(ctx),
database.UpsertChatDiffStatusReferenceParams{
ChatID: cachedStatusChat.ID,
Url: sql.NullString{},
GitBranch: "feature/diff-status",
GitRemoteOrigin: "git@github.com:coder/coder.git",
StaleAt: staleAt,
},
)
require.NoError(t, err)
_, err = db.UpsertChatDiffStatus(
dbauthz.AsSystemRestricted(ctx),
database.UpsertChatDiffStatusParams{
ChatID: cachedStatusChat.ID,
GitRemoteOrigin: "git@github.com:coder/coder.git",
GitBranch: "feature/diff-status",
Url: sql.NullString{},
PullRequestState: sql.NullString{
String: " open ",
Valid: true,
},
ChangesRequested: true,
Additions: 11,
Deletions: 4,
ChangedFiles: 3,
RefreshedAt: refreshedAt,
StaleAt: staleAt,
},
)
require.NoError(t, err)
cachedChat, err := client.GetChat(ctx, cachedStatusChat.ID)
require.NoError(t, err)
require.Equal(t, cachedStatusChat.ID, cachedChat.ID)
require.NotNil(t, cachedChat.DiffStatus)
cachedStatus := cachedChat.DiffStatus
require.Equal(t, cachedStatusChat.ID, cachedStatus.ChatID)
require.NotNil(t, cachedStatus.URL)
require.Equal(t, "https://github.com/coder/coder/tree/feature/diff-status", *cachedStatus.URL)
require.NotNil(t, cachedStatus.PullRequestState)
require.Equal(t, "open", *cachedStatus.PullRequestState)
require.True(t, cachedStatus.ChangesRequested)
require.EqualValues(t, 11, cachedStatus.Additions)
require.EqualValues(t, 4, cachedStatus.Deletions)
require.EqualValues(t, 3, cachedStatus.ChangedFiles)
require.NotNil(t, cachedStatus.RefreshedAt)
require.WithinDuration(t, refreshedAt, *cachedStatus.RefreshedAt, time.Second)
require.NotNil(t, cachedStatus.StaleAt)
require.WithinDuration(t, staleAt, *cachedStatus.StaleAt, time.Second)
})
t.Run("NotFoundForDifferentUser", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
createdChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "private chat",
},
},
})
require.NoError(t, err)
otherClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
otherClient := codersdk.NewExperimentalClient(otherClientRaw)
_, err = otherClient.GetChat(ctx, createdChat.ID)
requireSDKError(t, err, http.StatusNotFound)
})
}
func TestGetChatDiffContents(t *testing.T) {
t.Parallel()
t.Run("SuccessWithCachedRepositoryReference", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
DeploymentValues: coderdtest.DeploymentValues(t),
ExternalAuthConfigs: []*externalauth.Config{
{
ID: "gitlab-test",
Type: "gitlab",
Regex: regexp.MustCompile(`gitlab\.example\.com`),
},
},
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
db := api.Database
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "diff contents with cached repository reference",
})
_, err := db.UpsertChatDiffStatusReference(
dbauthz.AsSystemRestricted(ctx),
database.UpsertChatDiffStatusReferenceParams{
ChatID: chat.ID,
Url: sql.NullString{},
GitBranch: "feature/cached-diff",
GitRemoteOrigin: "https://gitlab.example.com/acme/project.git",
StaleAt: time.Now().UTC().Add(time.Hour),
},
)
require.NoError(t, err)
diffContents, err := client.GetChatDiffContents(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, chat.ID, diffContents.ChatID)
require.NotNil(t, diffContents.Provider)
require.Equal(t, "gitlab", *diffContents.Provider)
require.NotNil(t, diffContents.RemoteOrigin)
require.Equal(t, "https://gitlab.example.com/acme/project.git", *diffContents.RemoteOrigin)
require.NotNil(t, diffContents.Branch)
require.Equal(t, "feature/cached-diff", *diffContents.Branch)
require.Nil(t, diffContents.PullRequestURL)
require.Empty(t, diffContents.Diff)
})
t.Run("SuccessWithoutCachedReference", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "diff contents test",
},
},
})
require.NoError(t, err)
diffContents, err := client.GetChatDiffContents(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, chat.ID, diffContents.ChatID)
require.Nil(t, diffContents.Provider)
require.Nil(t, diffContents.RemoteOrigin)
require.Nil(t, diffContents.Branch)
require.Nil(t, diffContents.PullRequestURL)
require.Empty(t, diffContents.Diff)
})
t.Run("PartialSelectorIsRejected", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "partial selector test",
},
},
})
require.NoError(t, err)
res, err := client.Request(ctx, http.MethodGet,
fmt.Sprintf("/api/v2/chats/%s/diff?branch=feature/test", chat.ID), nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusBadRequest, res.StatusCode)
})
t.Run("UnmatchedSelectorIsNotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "unmatched selector test",
},
},
})
require.NoError(t, err)
// The chat tracks no refs at all, yet the complete selector
// must still return 404 rather than an empty 200.
res, err := client.Request(ctx, http.MethodGet,
fmt.Sprintf("/api/v2/chats/%s/diff?origin=https%%3A%%2F%%2Fgithub.com%%2Fcoder%%2Fcoder.git&branch=does%%2Fnot%%2Fexist", chat.ID), nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
t.Run("DiscoveryWriteKeysStoredRef", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
const gitToken = "test-git-token"
var githubServer *httptest.Server
githubServer = httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// The provider accepts only https URLs, so the fake server
// uses TLS and every URL string uses the https scheme.
host := strings.TrimPrefix(githubServer.URL, "https://")
w.Header().Set("Content-Type", "application/json")
switch {
case strings.HasSuffix(r.URL.Path, "/pulls"):
_, _ = w.Write([]byte(`[{"html_url": "https://` + host + `/acme/project/pull/7", "number": 7}]`))
case strings.HasSuffix(r.URL.Path, "/reviews"):
_, _ = w.Write([]byte(`[]`))
case strings.Contains(r.URL.Path, "/compare/"):
w.Header().Set("Content-Type", "text/plain")
_, _ = w.Write([]byte("diff --git a/main.go b/main.go"))
default:
_, _ = w.Write([]byte(`{"default_branch": "main", "state": "open", "number": 7}`))
}
}))
t.Cleanup(githubServer.Close)
// The provider parses the origin against the fake host, so the
// stored origin must use it too.
host := strings.TrimPrefix(githubServer.URL, "https://")
origin := "https://" + host + "/acme/project.git"
prURL := "https://" + host + "/acme/project/pull/7"
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
DeploymentValues: coderdtest.DeploymentValues(t),
ExternalAuthConfigs: []*externalauth.Config{
{
ID: "github-test",
Type: "github",
Regex: regexp.MustCompile(`^https?://` + regexp.QuoteMeta(host) + `(/.*)?$`),
APIBaseURL: githubServer.URL + "/api/v3",
HTTPClient: githubServer.Client(),
RefreshGroup: new(singleflight.Group),
},
},
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
db := api.Database
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
_, err := db.InsertExternalAuthLink(dbauthz.AsSystemRestricted(ctx), database.InsertExternalAuthLinkParams{
ProviderID: "github-test",
UserID: user.UserID,
OAuthAccessToken: gitToken,
OAuthExpiry: dbtime.Now().Add(24 * time.Hour),
CreatedAt: dbtime.Now(),
UpdatedAt: dbtime.Now(),
})
require.NoError(t, err)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "discovery write keys stored ref",
})
// A reported ref with no stored PR URL, so the diff GET must
// resolve the PR upstream.
_, err = db.UpsertChatDiffStatusReference(
dbauthz.AsSystemRestricted(ctx),
database.UpsertChatDiffStatusReferenceParams{
ChatID: chat.ID,
Url: sql.NullString{},
GitBranch: "feature/keyed-discovery",
GitRemoteOrigin: origin,
StaleAt: time.Now().UTC().Add(time.Hour),
},
)
require.NoError(t, err)
diffContents, err := client.GetChatDiffContents(ctx, chat.ID)
require.NoError(t, err)
require.NotNil(t, diffContents.Provider)
require.NotNil(t, diffContents.PullRequestURL)
require.Equal(t, prURL, *diffContents.PullRequestURL)
statuses, err := db.GetChatDiffStatusesByChatID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Len(t, statuses, 1, "the discovery write must update the reported ref, not add a row")
require.Equal(t, "feature/keyed-discovery", statuses[0].GitBranch)
require.Equal(t, origin, statuses[0].GitRemoteOrigin)
require.True(t, statuses[0].Url.Valid)
require.Equal(t, prURL, statuses[0].Url.String)
})
t.Run("DiscoveryWriteDoesNotReorderPrimary", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
db, _ := dbtestutil.NewDB(t)
user := dbgen.User(t, db, database.User{})
org := dbgen.Organization(t, db, database.Organization{})
_ = dbgen.ChatProvider(t, db, database.ChatProvider{})
modelCfg := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
Model: "test-model",
ContextLimit: 100000,
})
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: org.ID,
OwnerID: user.ID,
LastModelConfigID: modelCfg.ID,
Title: "discovery-write-primary-order",
})
// An old ref, then a newer ref reported later. The newer
// report is the primary.
_, err := db.UpsertChatDiffStatusReference(ctx, database.UpsertChatDiffStatusReferenceParams{
ChatID: chat.ID,
GitBranch: "old",
GitRemoteOrigin: "https://github.com/o/r",
StaleAt: time.Now().Add(-2 * time.Minute),
Url: sql.NullString{},
})
require.NoError(t, err)
_, err = db.UpsertChatDiffStatusReference(ctx, database.UpsertChatDiffStatusReferenceParams{
ChatID: chat.ID,
GitBranch: "new",
GitRemoteOrigin: "https://github.com/o/r",
StaleAt: time.Now().Add(-time.Minute),
Url: sql.NullString{},
})
require.NoError(t, err)
before, err := db.GetChatDiffStatusesByChatID(ctx, chat.ID)
require.NoError(t, err)
require.Len(t, before, 2)
require.Equal(t, "new", db2sdk.PrimaryChatDiffStatus(before).GitBranch)
// A discovery write lands on the old ref after the new one
// was reported, as an in-flight diff GET would.
err = db.UpdateChatDiffStatusReferenceURL(ctx, database.UpdateChatDiffStatusReferenceURLParams{
ChatID: chat.ID,
GitBranch: "old",
GitRemoteOrigin: "https://github.com/o/r",
StaleAt: time.Now().Add(-time.Minute),
Url: "https://github.com/o/r/pull/7",
})
require.NoError(t, err)
// The discovery write must not steal the primary from the
// newer report.
after, err := db.GetChatDiffStatusesByChatID(ctx, chat.ID)
require.NoError(t, err)
require.Len(t, after, 2)
require.Equal(t, "new", db2sdk.PrimaryChatDiffStatus(after).GitBranch, "discovery must not change the primary")
require.Equal(t, "old", after[0].GitBranch)
require.Equal(t, "https://github.com/o/r/pull/7", after[0].Url.String)
})
t.Run("RefSelectorFetchesThatRefsDiff", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
DeploymentValues: coderdtest.DeploymentValues(t),
ExternalAuthConfigs: []*externalauth.Config{
{
ID: "gitlab-test",
Type: "gitlab",
Regex: regexp.MustCompile(`gitlab\.example\.com`),
},
},
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
db := api.Database
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "sdk ref selector",
})
// Two tracked refs. The later report is the primary.
for _, ref := range []struct {
branch string
staleDelta time.Duration
}{
{branch: "feature/secondary", staleDelta: 2 * time.Hour},
{branch: "feature/primary", staleDelta: time.Hour},
} {
_, err := db.UpsertChatDiffStatusReference(
dbauthz.AsSystemRestricted(ctx),
database.UpsertChatDiffStatusReferenceParams{
ChatID: chat.ID,
Url: sql.NullString{},
GitBranch: ref.branch,
GitRemoteOrigin: "https://gitlab.example.com/acme/project.git",
StaleAt: time.Now().UTC().Add(ref.staleDelta),
},
)
require.NoError(t, err)
}
// A selector-free call returns the primary's diff, so the
// selector is the only way to reach the secondary.
diff, err := client.GetChatDiffContents(ctx, chat.ID, codersdk.WithChatDiffStatusRef(
codersdk.DiffStatusRef{
RemoteOrigin: "https://gitlab.example.com/acme/project.git",
GitBranch: "feature/secondary",
},
))
require.NoError(t, err)
require.Equal(t, chat.ID, diff.ChatID)
require.NotNil(t, diff.Branch)
require.Equal(t, "feature/secondary", *diff.Branch)
// Without the selector, the endpoint must return the
// primary's branch.
diff, err = client.GetChatDiffContents(ctx, chat.ID)
require.NoError(t, err)
require.NotNil(t, diff.Branch)
require.Equal(t, "feature/primary", *diff.Branch)
})
t.Run("NotFoundForDifferentUser", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
createdChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "private chat",
},
},
})
require.NoError(t, err)
otherClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
otherClient := codersdk.NewExperimentalClient(otherClientRaw)
_, err = otherClient.GetChatDiffContents(ctx, createdChat.ID)
requireSDKError(t, err, http.StatusNotFound)
})
}
func TestDeleteChatQueuedMessage(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "delete queued message route test",
Status: database.ChatStatusError,
})
deleteContent, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("queued message for delete route"),
})
require.NoError(t, err)
queuedMessage := insertTestChatQueuedMessage(ctx, t, db, chat.ID, deleteContent, modelConfig.ID)
res, err := client.Request(
ctx,
http.MethodDelete,
fmt.Sprintf("/api/v2/chats/%s/queue/%d", chat.ID, queuedMessage.ID),
nil,
)
require.NoError(t, err)
res.Body.Close()
require.Equal(t, http.StatusNoContent, res.StatusCode)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
for _, queued := range messagesResult.QueuedMessages {
require.NotEqual(t, queuedMessage.ID, queued.ID)
}
queuedMessages, err := db.GetChatQueuedMessages(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
for _, queued := range queuedMessages {
require.NotEqual(t, queuedMessage.ID, queued.ID)
}
})
t.Run("InvalidQueuedMessageID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "delete queued invalid id",
})
invalidRes, err := client.Request(
ctx,
http.MethodDelete,
fmt.Sprintf("/api/v2/chats/%s/queue/not-an-int", chat.ID),
nil,
)
require.NoError(t, err)
defer invalidRes.Body.Close()
err = codersdk.ReadBodyAsError(invalidRes)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid queued message ID.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, "invalid syntax")
})
t.Run("ArchivedChat", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "delete queued archived",
})
queuedContent, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("queued"),
})
require.NoError(t, err)
queuedMessage := insertTestChatQueuedMessage(ctx, t, db, chat.ID, queuedContent, chat.LastModelConfigID)
_, err = db.ArchiveChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
res, err := client.Request(
ctx,
http.MethodDelete,
fmt.Sprintf("/api/v2/chats/%s/queue/%d", chat.ID, queuedMessage.ID),
nil,
)
require.NoError(t, err)
defer res.Body.Close()
sdkErr := requireSDKError(t, codersdk.ReadBodyAsError(res), http.StatusBadRequest)
require.Equal(t, "Cannot delete queued messages in an archived chat.", sdkErr.Message)
})
}
func TestPromoteChatQueuedMessage(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "promote queued message route test",
Status: database.ChatStatusError,
})
// An earlier message gives the stream replay below an after_id
// cursor that sits before the promoted message.
earlier := dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
CreatedBy: uuid.NullUUID{UUID: user.UserID, Valid: true},
ModelConfigID: uuid.NullUUID{UUID: modelConfig.ID, Valid: true},
})
const queuedText = "queued message for promote route"
queuedContent, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText(queuedText),
})
require.NoError(t, err)
queuedMessage := insertTestChatQueuedMessage(ctx, t, db, chat.ID, queuedContent, chat.LastModelConfigID)
promoteRes, err := client.Request(
ctx,
http.MethodPost,
fmt.Sprintf("/api/v2/chats/%s/queue/%d/promote", chat.ID, queuedMessage.ID),
nil,
)
require.NoError(t, err)
defer promoteRes.Body.Close()
require.Equal(t, http.StatusAccepted, promoteRes.StatusCode)
var resp codersdk.Response
require.NoError(t, json.NewDecoder(promoteRes.Body).Decode(&resp))
require.NotEmpty(t, resp.Message)
messagesResult, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
for _, queued := range messagesResult.QueuedMessages {
require.NotEqual(t, queuedMessage.ID, queued.ID)
}
var promoted *codersdk.ChatMessage
for i, msg := range messagesResult.Messages {
if msg.Role != codersdk.ChatMessageRoleUser {
continue
}
for _, part := range msg.Content {
if part.Type == codersdk.ChatMessagePartTypeText && part.Text == queuedText {
promoted = &messagesResult.Messages[i]
}
}
}
require.NotNil(t, promoted, "promoted message must appear in chat history")
require.Equal(t, ptr.Ref(queuedMessage.ID), promoted.QueuedMessageID,
"promoted message links to its queued message")
require.Greater(t, promoted.ID, earlier.ID)
events, closer, err := client.StreamChat(ctx, chat.ID, &codersdk.StreamChatOptions{
AfterID: ptr.Ref(earlier.ID),
})
require.NoError(t, err)
defer closer.Close()
for replayed := false; !replayed; {
select {
case <-ctx.Done():
require.FailNow(t, "timed out waiting for the promoted message replay")
case event, ok := <-events:
require.True(t, ok, "stream closed before the promoted message replay")
if event.Type != codersdk.ChatStreamEventTypeMessage || event.Message == nil {
continue
}
require.NotEqual(t, earlier.ID, event.Message.ID, "after_id excludes earlier messages")
if event.Message.ID == promoted.ID {
require.Equal(t, ptr.Ref(queuedMessage.ID), event.Message.QueuedMessageID,
"after_id replay keeps the queued message link")
replayed = true
}
}
}
queuedMessages, err := db.GetChatQueuedMessages(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
for _, queued := range queuedMessages {
require.NotEqual(t, queuedMessage.ID, queued.ID)
}
})
t.Run("SendToErroredChatLinksPromotedHead", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "send to errored chat promotes queue head",
Status: database.ChatStatusError,
})
headContent, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("queued head"),
})
require.NoError(t, err)
head := insertTestChatQueuedMessage(ctx, t, db, chat.ID, headContent, chat.LastModelConfigID)
resp, err := client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "new tail",
}},
BusyBehavior: codersdk.ChatBusyBehaviorQueue,
})
require.NoError(t, err)
require.True(t, resp.Queued)
require.NotNil(t, resp.QueuedMessage)
require.NotEqual(t, head.ID, resp.QueuedMessage.ID)
var promoted *codersdk.ChatMessage
for i, msg := range resp.Messages {
if msg.Role == codersdk.ChatMessageRoleUser {
require.Nil(t, promoted, "only the old head is promoted")
promoted = &resp.Messages[i]
}
}
require.NotNil(t, promoted, "the response includes the promoted old head")
require.Equal(t, ptr.Ref(head.ID), promoted.QueuedMessageID,
"the promoted old head links to its own queued message, not the new tail")
})
t.Run("ForeignModelWithoutLocalDefaultReturnsGuidance", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
_ = coderdtest.CreateFirstUser(t, client.Client)
foreignConfig := createChatModel(t, client)
chatOrg := dbgen.Organization(t, db, database.Organization{IsDefault: false})
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, chatOrg.ID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: chatOrg.ID,
OwnerID: member.ID,
LastModelConfigID: foreignConfig.ID,
Title: "promote queued foreign model without fallback",
Status: database.ChatStatusError,
})
queuedContent, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("require a local model for promotion"),
})
require.NoError(t, err)
queuedMessage := insertTestChatQueuedMessage(ctx, t, db, chat.ID, queuedContent, foreignConfig.ID)
promoteRes, err := memberClient.Request(
ctx,
http.MethodPost,
fmt.Sprintf("/api/v2/chats/%s/queue/%d/promote", chat.ID, queuedMessage.ID),
nil,
)
require.NoError(t, err)
defer promoteRes.Body.Close()
err = codersdk.ReadBodyAsError(promoteRes)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "No chat model is available in this organization.", sdkErr.Message)
require.Equal(t, "Ask an organization administrator to configure and enable a chat model.", sdkErr.Detail)
remaining, err := db.GetChatQueuedMessageByID(dbauthz.AsSystemRestricted(ctx), database.GetChatQueuedMessageByIDParams{
ID: queuedMessage.ID,
ChatID: chat.ID,
})
require.NoError(t, err)
require.Equal(t, queuedMessage.ID, remaining.ID)
})
t.Run("InvalidQueuedMessageID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "promote queued invalid id",
})
invalidRes, err := client.Request(
ctx,
http.MethodPost,
fmt.Sprintf("/api/v2/chats/%s/queue/not-an-int/promote", chat.ID),
nil,
)
require.NoError(t, err)
defer invalidRes.Body.Close()
err = codersdk.ReadBodyAsError(invalidRes)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid queued message ID.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, "invalid syntax")
})
t.Run("MemberCanPromoteOwnQueuedMessage", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: member.ID,
LastModelConfigID: modelConfig.ID,
Title: "promote queued as member",
Status: database.ChatStatusError,
})
queuedContent, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("queued message promoted by member"),
})
require.NoError(t, err)
queuedMessage := insertTestChatQueuedMessage(ctx, t, db, chat.ID, queuedContent, chat.LastModelConfigID)
promoteRes, err := memberClient.Request(
ctx,
http.MethodPost,
fmt.Sprintf("/api/v2/chats/%s/queue/%d/promote", chat.ID, queuedMessage.ID),
nil,
)
require.NoError(t, err)
defer promoteRes.Body.Close()
require.Equal(t, http.StatusAccepted, promoteRes.StatusCode)
})
t.Run("ArchivedChat", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "promote queued archived",
})
queuedContent, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("queued"),
})
require.NoError(t, err)
queuedMessage := insertTestChatQueuedMessage(ctx, t, db, chat.ID, queuedContent, chat.LastModelConfigID)
// Archive the chat.
_, err = db.ArchiveChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
promoteRes, err := client.Request(
ctx,
http.MethodPost,
fmt.Sprintf("/api/v2/chats/%s/queue/%d/promote", chat.ID, queuedMessage.ID),
nil,
)
require.NoError(t, err)
defer promoteRes.Body.Close()
require.Equal(t, http.StatusBadRequest, promoteRes.StatusCode)
promoteErr := codersdk.ReadBodyAsError(promoteRes)
var promoteSDKErr *codersdk.Error
require.ErrorAs(t, promoteErr, &promoteSDKErr)
require.Contains(t, promoteSDKErr.Message, "archived")
})
t.Run("WhileRequiresAction", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db, api := newChatClientWithAPIAndDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
const dynamicToolName = "my_dynamic_tool"
dynamicTools := []mcp.Tool{{
Name: dynamicToolName,
Description: "a test dynamic tool",
InputSchema: map[string]any{"type": "object"},
}}
dtJSON, err := json.Marshal(dynamicTools)
require.NoError(t, err)
chat, err := db.InsertChat(dbauthz.AsSystemRestricted(ctx), database.InsertChatParams{
OrganizationID: user.OrganizationID,
Status: database.ChatStatusWaiting,
ClientType: database.ChatClientTypeUi,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "promote queued requires-action route test",
DynamicTools: pqtype.NullRawMessage{RawMessage: dtJSON, Valid: true},
})
require.NoError(t, err)
const pendingToolCallID = "call_pending"
assistantContent, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{{
Type: codersdk.ChatMessagePartTypeToolCall,
ToolCallID: pendingToolCallID,
ToolName: dynamicToolName,
Args: json.RawMessage(`{"x":1}`),
}})
require.NoError(t, err)
_, err = db.InsertChatMessages(dbauthz.AsSystemRestricted(ctx), database.InsertChatMessagesParams{
ChatID: chat.ID,
CreatedBy: []uuid.UUID{uuid.Nil},
ModelConfigID: []uuid.UUID{modelConfig.ID},
Role: []database.ChatMessageRole{database.ChatMessageRoleAssistant},
ContentVersion: []int16{chatprompt.CurrentContentVersion},
Content: []string{string(assistantContent.RawMessage)},
Visibility: []database.ChatMessageVisibility{database.ChatMessageVisibilityBoth},
InputTokens: []int64{0},
OutputTokens: []int64{0},
TotalTokens: []int64{0},
ReasoningTokens: []int64{0},
CacheCreationTokens: []int64{0},
CacheReadTokens: []int64{0},
ContextLimit: []int64{0},
Compressed: []bool{false},
RuntimeMs: []int64{0},
})
require.NoError(t, err)
// The worker can take over an unowned requires_action chat. A
// missing deadline makes it cancel the pending tool call at once.
_, err = db.UpdateChatExecutionState(dbauthz.AsSystemRestricted(ctx), database.UpdateChatExecutionStateParams{
ID: chat.ID,
Status: database.ChatStatusRequiresAction,
RequiresActionDeadlineAt: sql.NullTime{Time: dbtime.Now().Add(time.Hour), Valid: true},
})
require.NoError(t, err)
const queuedText = "queued message for requires-action promote"
queuedContent, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText(queuedText),
})
require.NoError(t, err)
queuedMessage := insertTestChatQueuedMessage(ctx, t, db, chat.ID, queuedContent, chat.LastModelConfigID)
promoteRes, err := client.Request(
ctx,
http.MethodPost,
fmt.Sprintf("/api/v2/chats/%s/queue/%d/promote", chat.ID, queuedMessage.ID),
nil,
)
require.NoError(t, err)
defer promoteRes.Body.Close()
require.Equal(t, http.StatusAccepted, promoteRes.StatusCode)
var resp codersdk.Response
require.NoError(t, json.NewDecoder(promoteRes.Body).Decode(&resp))
require.NotEmpty(t, resp.Message)
after, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, database.ChatStatusRequiresAction, after.Status,
"Send now does not cancel the pending tool call")
queued, err := db.GetChatQueuedMessages(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Len(t, queued, 1)
require.Equal(t, queuedMessage.ID, queued[0].ID)
require.Equal(t, database.ChatBusyBehaviorSteer, queued[0].BusyBehavior)
err = client.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{{ToolCallID: pendingToolCallID, Output: json.RawMessage(`"done"`)}},
})
require.NoError(t, err)
coderdtest.WaitForChatSettled(ctx, t, api, chat.ID)
messages, err := db.GetChatMessagesByChatID(dbauthz.AsSystemRestricted(ctx), database.GetChatMessagesByChatIDParams{
ChatID: chat.ID,
AfterID: 0,
})
require.NoError(t, err)
var resultID, promotedID, replyID int64
for _, msg := range messages {
parts, err := chatprompt.ParseContent(msg)
require.NoError(t, err)
for _, part := range parts {
if msg.Role == database.ChatMessageRoleTool &&
part.Type == codersdk.ChatMessagePartTypeToolResult &&
part.ToolCallID == pendingToolCallID {
require.False(t, part.IsError, "the submitted result is the only result")
resultID = msg.ID
}
if msg.Role == database.ChatMessageRoleUser &&
part.Type == codersdk.ChatMessagePartTypeText &&
part.Text == queuedText {
promotedID = msg.ID
}
}
if msg.Role == database.ChatMessageRoleAssistant && promotedID != 0 && replyID == 0 {
replyID = msg.ID
}
}
require.NotZero(t, resultID, "expected the submitted tool result")
require.Less(t, resultID, promotedID,
"the steered message goes in after the submitted tool result")
require.NotZero(t, replyID,
"expected an assistant reply after the steered message")
queuedRemaining, err := db.GetChatQueuedMessages(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Empty(t, queuedRemaining)
})
t.Run("WhileRunning", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat, err := db.InsertChat(dbauthz.AsSystemRestricted(ctx), database.InsertChatParams{
OrganizationID: user.OrganizationID,
Status: database.ChatStatusWaiting,
ClientType: database.ChatClientTypeUi,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "promote queued running route test",
})
require.NoError(t, err)
// No real worker runs here, so this test stops before delivery.
workerID := uuid.New()
_, err = db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusRunning,
WorkerID: uuid.NullUUID{UUID: workerID, Valid: true},
StartedAt: sql.NullTime{Time: dbtime.Now(), Valid: true},
HeartbeatAt: sql.NullTime{Time: dbtime.Now(), Valid: true},
})
require.NoError(t, err)
queuedContent, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("running-promote"),
})
require.NoError(t, err)
queuedMessage := insertTestChatQueuedMessage(ctx, t, db, chat.ID, queuedContent, chat.LastModelConfigID)
promoteRes, err := client.Request(
ctx,
http.MethodPost,
fmt.Sprintf("/api/v2/chats/%s/queue/%d/promote", chat.ID, queuedMessage.ID),
nil,
)
require.NoError(t, err)
defer promoteRes.Body.Close()
require.Equal(t, http.StatusAccepted, promoteRes.StatusCode)
var resp codersdk.Response
require.NoError(t, json.NewDecoder(promoteRes.Body).Decode(&resp))
require.NotEmpty(t, resp.Message)
after, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, database.ChatStatusRunning, after.Status,
"Send now does not interrupt a running chat")
require.Equal(t, uuid.NullUUID{UUID: workerID, Valid: true}, after.WorkerID,
"Send now keeps the worker")
queuedRemaining, err := db.GetChatQueuedMessages(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Len(t, queuedRemaining, 1)
require.Equal(t, queuedMessage.ID, queuedRemaining[0].ID,
"queued message ID must stay stable when it moves to the steer lane")
require.Equal(t, database.ChatBusyBehaviorSteer, queuedRemaining[0].BusyBehavior)
})
}
func TestPostChatFile(t *testing.T) {
t.Parallel()
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
t.Run("Success/PNG", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
// Valid PNG header + padding.
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
resp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "test.png", bytes.NewReader(data))
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, resp.ID)
})
t.Run("MissingFilename", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
_, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "", bytes.NewReader(data))
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "Filename is required")
require.Contains(t, sdkErr.Detail, "Content-Disposition")
})
t.Run("Success/TextPlain", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
data := []byte(`This is a test paste.
With multiple lines.
`)
resp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "text/plain", "test.txt", bytes.NewReader(data))
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, resp.ID)
})
t.Run("Success/TextPlainRefinesToJSON", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
resp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "text/plain", "pasted-text.txt", bytes.NewReader([]byte(`{"ok":true}`)))
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, resp.ID)
})
t.Run("Success/TextPlainRefinesToCSV", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
resp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "text/plain", "pasted-text.txt", bytes.NewReader([]byte(`name,count
widgets,3
`)))
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, resp.ID)
})
t.Run("Success/OctetStreamPNG", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploaded, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "application/octet-stream", "test.png", bytes.NewReader(data))
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, uploaded.ID)
got, contentType, err := client.GetChatFile(ctx, uploaded.ID)
require.NoError(t, err)
require.Equal(t, "image/png", contentType)
require.Equal(t, data, got)
})
t.Run("Success/OctetStreamMarkdown", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
data := []byte(`# Markdown upload
This arrived as octet-stream.
`)
uploaded, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "application/octet-stream", "notes.md", bytes.NewReader(data))
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, uploaded.ID)
got, contentType, err := client.GetChatFile(ctx, uploaded.ID)
require.NoError(t, err)
require.Equal(t, "text/markdown", contentType)
require.Equal(t, data, got)
})
t.Run("OctetStreamRejectsUnsupportedBytes", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "application/octet-stream", "payload.zip", bytes.NewReader([]byte("PK\x03\x04")))
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "Unsupported file type")
})
t.Run("UnsupportedContentType", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "application/zip", "test.zip", bytes.NewReader([]byte("PK\x03\x04")))
requireSDKError(t, err, http.StatusBadRequest)
})
t.Run("Success/SVG", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/svg+xml", "test.svg", bytes.NewReader([]byte(`<svg xmlns="http://www.w3.org/2000/svg"><script>alert(1)</script></svg>`)))
require.NoError(t, err)
})
t.Run("Success/SVGPastedAsText", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
// Large pastes arrive as text/plain; SVG bytes are stored as image/svg+xml.
uploaded, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "text/plain", "pasted-text-2026-01-01-00-00-00.txt", bytes.NewReader([]byte(`<?xml version="1.0"?><svg xmlns="http://www.w3.org/2000/svg"><rect/></svg>`)))
require.NoError(t, err)
_, contentType, err := client.GetChatFile(ctx, uploaded.ID)
require.NoError(t, err)
require.Equal(t, "image/svg+xml", contentType)
})
t.Run("ContentSniffingRejectsPNGAsText", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
// Valid 1x1 PNG declared as text/plain should still be rejected.
data := []byte{
0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
0x08, 0x04, 0x00, 0x00, 0x00, 0xB5, 0x1C, 0x0C,
0x02, 0x00, 0x00, 0x00, 0x0B, 0x49, 0x44, 0x41,
0x54, 0x78, 0xDA, 0x63, 0xFC, 0xFF, 0x1F, 0x00,
0x03, 0x03, 0x02, 0x00, 0xEF, 0x9A, 0x1A, 0x2A,
0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44,
0xAE, 0x42, 0x60, 0x82,
}
_, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "text/plain", "test.txt", bytes.NewReader(data))
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "does not match")
})
t.Run("ContentSniffingRejectsPlainTextAsJSON", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "application/json", "payload.json", bytes.NewReader([]byte("not actually json")))
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "does not match")
})
t.Run("TooLarge", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
// 10 MB + 1 byte, with valid PNG header to pass media type check.
data := make([]byte, 10<<20+1)
copy(data, []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A})
_, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "test.png", bytes.NewReader(data))
require.Error(t, err)
})
t.Run("Success/TextPlainHTMLLikeContent", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
data := []byte(`<!DOCTYPE html>
<html><body><p>Paste me as plain text.</p></body></html>
`)
resp, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "text/plain", "snippet.txt", bytes.NewReader(data))
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, resp.ID)
})
t.Run("MissingOrganization", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
res, err := client.Request(ctx, http.MethodPost, "/api/v2/chats/files", bytes.NewReader(data), func(r *http.Request) {
r.Header.Set("Content-Type", "image/png")
})
require.NoError(t, err)
defer res.Body.Close()
err = codersdk.ReadBodyAsError(res)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "Missing organization")
})
t.Run("InvalidOrganization", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
res, err := client.Request(ctx, http.MethodPost, "/api/v2/chats/files?organization=not-a-uuid", bytes.NewReader(data), func(r *http.Request) {
r.Header.Set("Content-Type", "image/png")
})
require.NoError(t, err)
defer res.Body.Close()
err = codersdk.ReadBodyAsError(res)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "Invalid organization ID")
})
t.Run("WrongOrganization", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
_, err := client.UploadChatFile(ctx, uuid.New(), "image/png", "test.png", bytes.NewReader(data))
require.Error(t, err)
var sdkErr *codersdk.Error
require.ErrorAs(t, err, &sdkErr)
// dbauthz returns 404 or 500 depending on how the org lookup
// fails; 403 is also possible. Any non-success code is valid.
require.GreaterOrEqual(t, sdkErr.StatusCode(), http.StatusBadRequest,
"expected error status, got %d", sdkErr.StatusCode())
})
t.Run("Unauthenticated", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
unauthed := codersdk.NewExperimentalClient(codersdk.New(client.URL))
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
_, err := unauthed.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "test.png", bytes.NewReader(data))
requireSDKError(t, err, http.StatusUnauthorized)
})
t.Run("MemberCanUploadChatFile", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploaded, err := memberClient.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "test.png", bytes.NewReader(data))
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, uploaded.ID)
})
}
func TestGetChatFile(t *testing.T) {
t.Parallel()
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploaded, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "test.png", bytes.NewReader(data))
require.NoError(t, err)
got, contentType, err := client.GetChatFile(ctx, uploaded.ID)
require.NoError(t, err)
require.Equal(t, "image/png", contentType)
require.Equal(t, data, got)
})
t.Run("CacheHeaders", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploaded, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "test.png", bytes.NewReader(data))
require.NoError(t, err)
res, err := client.Request(ctx, http.MethodGet,
fmt.Sprintf("/api/v2/chats/files/%s", uploaded.ID), nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
require.Equal(t, "private, max-age=31536000, immutable", res.Header.Get("Cache-Control"))
require.Equal(t, "nosniff", res.Header.Get("X-Content-Type-Options"))
require.Contains(t, res.Header.Get("Content-Disposition"), "inline")
require.Contains(t, res.Header.Get("Content-Disposition"), "test.png")
})
t.Run("PDFServedAsAttachment", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
uploaded, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "application/pdf", "report.pdf", bytes.NewReader([]byte("%PDF-1.7\n")))
require.NoError(t, err)
res, err := client.Request(ctx, http.MethodGet,
fmt.Sprintf("/api/v2/chats/files/%s", uploaded.ID), nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
require.Equal(t, "application/pdf", res.Header.Get("Content-Type"))
require.Equal(t, "nosniff", res.Header.Get("X-Content-Type-Options"))
disposition, params, err := mime.ParseMediaType(res.Header.Get("Content-Disposition"))
require.NoError(t, err)
require.Equal(t, "attachment", disposition)
require.Equal(t, "report.pdf", params["filename"])
})
t.Run("SVGServedAsAttachment", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
uploaded, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/svg+xml", "icon.svg", bytes.NewReader([]byte(`<svg xmlns="http://www.w3.org/2000/svg"/>`)))
require.NoError(t, err)
res, err := client.Request(ctx, http.MethodGet,
fmt.Sprintf("/api/v2/chats/files/%s", uploaded.ID), nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
require.Equal(t, "image/svg+xml", res.Header.Get("Content-Type"))
require.Equal(t, "nosniff", res.Header.Get("X-Content-Type-Options"))
disposition, params, err := mime.ParseMediaType(res.Header.Get("Content-Disposition"))
require.NoError(t, err)
require.Equal(t, "attachment", disposition)
require.Equal(t, "icon.svg", params["filename"])
})
t.Run("AgentArtifactZipServedAsAttachment", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, store := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
data := []byte("zip data")
//nolint:gocritic // Using AsChatd to mimic an agent-created artifact.
chatdCtx := dbauthz.AsChatd(ctx)
row, err := store.InsertChatFile(chatdCtx, database.InsertChatFileParams{
OwnerID: firstUser.UserID,
OrganizationID: firstUser.OrganizationID,
Name: "artifact.zip",
Mimetype: "application/zip",
Data: data,
})
require.NoError(t, err)
res, err := client.Request(ctx, http.MethodGet,
fmt.Sprintf("/api/v2/chats/files/%s", row.ID), nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
require.Equal(t, "application/zip", res.Header.Get("Content-Type"))
require.Equal(t, "nosniff", res.Header.Get("X-Content-Type-Options"))
disposition, params, err := mime.ParseMediaType(res.Header.Get("Content-Disposition"))
require.NoError(t, err)
require.Equal(t, "attachment", disposition)
require.Equal(t, "artifact.zip", params["filename"])
got, err := io.ReadAll(res.Body)
require.NoError(t, err)
require.Equal(t, data, got)
})
t.Run("LongFilename", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
longName := strings.Repeat("a", 300) + ".png"
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploaded, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", longName, bytes.NewReader(data))
require.NoError(t, err)
res, err := client.Request(ctx, http.MethodGet,
fmt.Sprintf("/api/v2/chats/files/%s", uploaded.ID), nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
// Filename should be truncated to chatfiles.MaxStoredFileNameBytes (255) bytes.
cd := res.Header.Get("Content-Disposition")
require.Contains(t, cd, "inline")
require.Contains(t, cd, strings.Repeat("a", 255))
require.NotContains(t, cd, strings.Repeat("a", 256))
})
t.Run("UnicodeFilename", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
// Upload with a non-ASCII filename using RFC 5987 encoding,
// which is what the frontend sends for Unicode filenames.
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploaded, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "スクリーンショット.png", bytes.NewReader(data))
require.NoError(t, err)
res, err := client.Request(ctx, http.MethodGet,
fmt.Sprintf("/api/v2/chats/files/%s", uploaded.ID), nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
cd := res.Header.Get("Content-Disposition")
require.Contains(t, cd, "inline")
_, params, err := mime.ParseMediaType(cd)
require.NoError(t, err)
require.Equal(t, "スクリーンショット.png", params["filename"])
})
t.Run("NotFound", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
coderdtest.CreateFirstUser(t, client.Client)
_, _, err := client.GetChatFile(ctx, uuid.New())
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("InvalidUUID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
coderdtest.CreateFirstUser(t, client.Client)
res, err := client.Request(ctx, http.MethodGet,
"/api/v2/chats/files/not-a-uuid", nil)
require.NoError(t, err)
defer res.Body.Close()
err = codersdk.ReadBodyAsError(res)
requireSDKError(t, err, http.StatusBadRequest)
})
t.Run("OtherUserForbidden", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploaded, err := client.UploadChatFile(ctx, firstUser.OrganizationID, "image/png", "test.png", bytes.NewReader(data))
require.NoError(t, err)
otherClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
otherClient := codersdk.NewExperimentalClient(otherClientRaw)
_, _, err = otherClient.GetChatFile(ctx, uploaded.ID)
requireSDKError(t, err, http.StatusNotFound)
})
}
func TestChatFileDownloadURL(t *testing.T) {
t.Parallel()
newClient := func(t *testing.T) (*codersdk.ExperimentalClient, jwtutils.StaticKey) {
t.Helper()
key := jwtutils.StaticKey{ID: "1", Key: []byte(strings.Repeat("k", 64))}
client := newChatClient(t, func(options *coderdtest.Options) {
options.ChatFileTokenKeyCache = key
})
return client, key
}
uploadPNG := func(t *testing.T, ctx context.Context, client *codersdk.ExperimentalClient, organizationID uuid.UUID, name string) (codersdk.UploadChatFileResponse, []byte) {
t.Helper()
data := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
uploaded, err := client.UploadChatFile(ctx, organizationID, "image/png", name, bytes.NewReader(data))
require.NoError(t, err)
return uploaded, data
}
get := func(t *testing.T, ctx context.Context, rawURL string) *http.Response {
t.Helper()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
return res
}
t.Run("MintAndRedeem", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, _ := newClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
uploaded, data := uploadPNG(t, ctx, client, firstUser.OrganizationID, "evidence.png")
download, err := client.ChatFileDownloadURL(ctx, uploaded.ID)
require.NoError(t, err)
require.Equal(t, int64(len(data)), download.SizeBytes)
require.Equal(t, fmt.Sprintf("%x", sha256.Sum256(data)), download.SHA256)
require.Equal(t, "evidence.png", download.Name)
require.Equal(t, "image/png", download.MimeType)
require.True(t, download.ExpiresAt.After(time.Now()))
// expires_at must match the JWT exp claim, which is stored at
// second precision; sub-second drift would overstate validity.
require.True(t, download.ExpiresAt.Equal(download.ExpiresAt.Truncate(time.Second)))
res := get(t, ctx, download.URL)
defer res.Body.Close()
require.Equal(t, http.StatusOK, res.StatusCode)
require.Equal(t, "image/png", res.Header.Get("Content-Type"))
require.Equal(t, "no-store", res.Header.Get("Cache-Control"))
got, err := io.ReadAll(res.Body)
require.NoError(t, err)
require.Equal(t, data, got)
})
t.Run("ExpiredToken", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, key := newClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
uploaded, _ := uploadPNG(t, ctx, client, firstUser.OrganizationID, "expired.png")
token, err := jwtutils.Sign(ctx, key, coderd.ChatFileDownloadClaims{
RegisteredClaims: jwtutils.RegisteredClaims{
Expiry: jwt.NewNumericDate(time.Now().Add(-time.Minute)),
IssuedAt: jwt.NewNumericDate(time.Now().Add(-2 * time.Minute)),
},
FileID: uploaded.ID,
UserID: firstUser.UserID,
})
require.NoError(t, err)
downloadURL := client.URL.JoinPath("api", "v2", "chats", "files", uploaded.ID.String(), "download")
query := downloadURL.Query()
query.Set("token", token)
downloadURL.RawQuery = query.Encode()
res := get(t, ctx, downloadURL.String())
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
t.Run("TamperedToken", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, _ := newClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
uploaded, _ := uploadPNG(t, ctx, client, firstUser.OrganizationID, "tampered.png")
download, err := client.ChatFileDownloadURL(ctx, uploaded.ID)
require.NoError(t, err)
downloadURL, err := url.Parse(download.URL)
require.NoError(t, err)
token := downloadURL.Query().Get("token")
require.NotEmpty(t, token)
first := byte('A')
if token[0] == first {
first = 'B'
}
query := downloadURL.Query()
query.Set("token", string(first)+token[1:])
downloadURL.RawQuery = query.Encode()
res := get(t, ctx, downloadURL.String())
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
t.Run("TokenFileMismatch", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, _ := newClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
fileA, _ := uploadPNG(t, ctx, client, firstUser.OrganizationID, "a.png")
fileB, _ := uploadPNG(t, ctx, client, firstUser.OrganizationID, "b.png")
download, err := client.ChatFileDownloadURL(ctx, fileA.ID)
require.NoError(t, err)
downloadURL, err := url.Parse(download.URL)
require.NoError(t, err)
downloadURL.Path = fmt.Sprintf("/api/v2/chats/files/%s/download", fileB.ID)
res := get(t, ctx, downloadURL.String())
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
t.Run("PlainGetRequiresAuthentication", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, _ := newClient(t)
anonymous := codersdk.NewExperimentalClient(codersdk.New(client.URL))
_, _, err := anonymous.GetChatFile(ctx, uuid.New())
requireSDKError(t, err, http.StatusUnauthorized)
})
t.Run("NonOwnerCannotMint", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, _ := newClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
uploaded, _ := uploadPNG(t, ctx, client, firstUser.OrganizationID, "owner.png")
otherClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
otherClient := codersdk.NewExperimentalClient(otherClientRaw)
_, err := otherClient.ChatFileDownloadURL(ctx, uploaded.ID)
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("RevokedShareCannotRedeem", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, _ := newClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
uploaded, _ := uploadPNG(t, ctx, client, firstUser.OrganizationID, "shared.png")
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "shared evidence"},
{Type: codersdk.ChatInputPartTypeFile, FileID: uploaded.ID},
},
})
require.NoError(t, err)
memberRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberRaw)
err = client.UpdateChatACL(ctx, chat.ID, codersdk.UpdateChatACL{
UserRoles: map[string]codersdk.ChatRole{member.ID.String(): codersdk.ChatRoleRead},
})
require.NoError(t, err)
// The member can mint while the share is active.
download, err := memberClient.ChatFileDownloadURL(ctx, uploaded.ID)
require.NoError(t, err)
// Revoking the share invalidates the already-minted URL because
// redemption rechecks the minting user's access live.
err = client.UpdateChatACL(ctx, chat.ID, codersdk.UpdateChatACL{
UserRoles: map[string]codersdk.ChatRole{member.ID.String(): codersdk.ChatRoleDeleted},
})
require.NoError(t, err)
res := get(t, ctx, download.URL)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
t.Run("SuspendedUserCannotRedeem", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, _ := newClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
memberRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberRaw)
uploaded, _ := uploadPNG(t, ctx, memberClient, firstUser.OrganizationID, "suspended.png")
download, err := memberClient.ChatFileDownloadURL(ctx, uploaded.ID)
require.NoError(t, err)
// Suspending the minting user invalidates the URL because
// redemption requires the token's user to still be active.
_, err = client.UpdateUserStatus(ctx, member.ID.String(), codersdk.UserStatusSuspended)
require.NoError(t, err)
res := get(t, ctx, download.URL)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
}
// seedChatGatewayRequest records one finished Coder Agents gateway request
// under sessionChatID, mirroring aibridged: the session ID is the spawning
// chat, and each usage is one provider response within that one request.
func seedChatGatewayRequest(t *testing.T, db database.Store, initiatorID, sessionChatID uuid.UUID, usages ...database.InsertAIBridgeTokenUsageParams) {
t.Helper()
now := dbtime.Now()
endedAt := now.Add(time.Second)
interception := dbgen.AIBridgeInterception(t, db, database.InsertAIBridgeInterceptionParams{
InitiatorID: initiatorID,
Provider: "anthropic",
Model: "claude-4",
StartedAt: now,
Client: sql.NullString{String: string(aibclient.CoderAgents), Valid: true},
ClientSessionID: sql.NullString{String: sessionChatID.String(), Valid: true},
}, &endedAt)
for _, usage := range usages {
usage.InterceptionID = interception.ID
usage.CreatedAt = now
dbgen.AIBridgeTokenUsage(t, db, usage)
}
}
func TestGetChatCost(t *testing.T) {
t.Parallel()
t.Run("RollsUpChatTree", func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
everyoneGroup := uuid.NullUUID{UUID: firstUser.OrganizationID, Valid: true}
rootChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "root chat",
})
childChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "child chat",
ParentChatID: uuid.NullUUID{UUID: rootChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: rootChat.ID, Valid: true},
})
grandchildChat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "grandchild chat",
ParentChatID: uuid.NullUUID{UUID: childChat.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: rootChat.ID, Valid: true},
})
// A subagent's requests carry the spawning chat's ID, so the child's
// spend lands on the root session and the grandchild's on the child.
seedChatGatewayRequest(t, db, firstUser.UserID, rootChat.ID, database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 500, Valid: true},
})
seedChatGatewayRequest(t, db, firstUser.UserID, rootChat.ID, database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 250, Valid: true},
})
seedChatGatewayRequest(t, db, firstUser.UserID, childChat.ID, database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 100, Valid: true},
})
ctx := testutil.Context(t, testutil.WaitLong)
for _, chatID := range []uuid.UUID{rootChat.ID, childChat.ID, grandchildChat.ID} {
cost, err := client.GetChatCost(ctx, chatID)
require.NoError(t, err)
require.Equal(t, chatID, cost.ChatID)
require.Equal(t, int64(850), cost.TotalCostMicros)
require.Equal(t, int64(3), cost.RequestCount)
require.Equal(t, int64(0), cost.UnpricedRequestCount)
}
})
t.Run("UnpricedRequests", func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
everyoneGroup := uuid.NullUUID{UUID: firstUser.OrganizationID, Valid: true}
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "unpriced chat",
})
seedChatGatewayRequest(t, db, firstUser.UserID, chat.ID, database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 400, Valid: true},
})
seedChatGatewayRequest(t, db, firstUser.UserID, chat.ID, database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
})
ctx := testutil.Context(t, testutil.WaitLong)
cost, err := client.GetChatCost(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, int64(400), cost.TotalCostMicros)
require.Equal(t, int64(2), cost.RequestCount)
require.Equal(t, int64(1), cost.UnpricedRequestCount)
})
t.Run("PartiallyPricedRequest", func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
everyoneGroup := uuid.NullUUID{UUID: firstUser.OrganizationID, Valid: true}
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "partially priced chat",
})
// One request, two provider responses, only one of them priced. The
// priced usage still counts towards the total, and the request is
// reported as unpriced so the total is not presented as exact.
seedChatGatewayRequest(t, db, firstUser.UserID, chat.ID,
database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 300, Valid: true},
},
database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
},
)
ctx := testutil.Context(t, testutil.WaitLong)
cost, err := client.GetChatCost(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, int64(300), cost.TotalCostMicros)
require.Equal(t, int64(1), cost.RequestCount)
require.Equal(t, int64(1), cost.UnpricedRequestCount)
})
t.Run("ZeroCostRequests", func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
everyoneGroup := uuid.NullUUID{UUID: firstUser.OrganizationID, Valid: true}
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "free chat",
})
// A recorded cost of zero is a free request, not an unpriced one.
seedChatGatewayRequest(t, db, firstUser.UserID, chat.ID, database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 0, Valid: true},
})
ctx := testutil.Context(t, testutil.WaitLong)
cost, err := client.GetChatCost(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, int64(0), cost.TotalCostMicros)
require.Equal(t, int64(1), cost.RequestCount)
require.Equal(t, int64(0), cost.UnpricedRequestCount)
})
t.Run("RequestWithoutUsage", func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
everyoneGroup := uuid.NullUUID{UUID: firstUser.OrganizationID, Valid: true}
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "failed request chat",
})
seedChatGatewayRequest(t, db, firstUser.UserID, chat.ID, database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 200, Valid: true},
})
// A request that fails upstream still ends, but records no usage. It
// counts as a request, adds no cost, and is not unpriced usage.
seedChatGatewayRequest(t, db, firstUser.UserID, chat.ID)
ctx := testutil.Context(t, testutil.WaitLong)
cost, err := client.GetChatCost(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, int64(200), cost.TotalCostMicros)
require.Equal(t, int64(2), cost.RequestCount)
require.Equal(t, int64(0), cost.UnpricedRequestCount)
})
t.Run("IsolatesSiblingChatTrees", func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
everyoneGroup := uuid.NullUUID{UUID: firstUser.OrganizationID, Valid: true}
firstRoot := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "first root chat",
})
secondRoot := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "second root chat",
})
secondChild := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "second root subagent",
ParentChatID: uuid.NullUUID{UUID: secondRoot.ID, Valid: true},
RootChatID: uuid.NullUUID{UUID: secondRoot.ID, Valid: true},
})
seedChatGatewayRequest(t, db, firstUser.UserID, firstRoot.ID, database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 500, Valid: true},
})
seedChatGatewayRequest(t, db, firstUser.UserID, secondRoot.ID, database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 120, Valid: true},
})
seedChatGatewayRequest(t, db, firstUser.UserID, secondChild.ID, database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 30, Valid: true},
})
ctx := testutil.Context(t, testutil.WaitLong)
firstCost, err := client.GetChatCost(ctx, firstRoot.ID)
require.NoError(t, err)
require.Equal(t, int64(500), firstCost.TotalCostMicros)
require.Equal(t, int64(1), firstCost.RequestCount)
for _, chatID := range []uuid.UUID{secondRoot.ID, secondChild.ID} {
secondCost, err := client.GetChatCost(ctx, chatID)
require.NoError(t, err)
require.Equal(t, int64(150), secondCost.TotalCostMicros)
require.Equal(t, int64(2), secondCost.RequestCount)
}
})
t.Run("ExcludesUnattributedUsageFromCost", func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "legacy chat",
})
// Usage recorded before group attribution existed never reached
// ai_user_daily_spend, so it must not appear as chat spend either. The
// request itself still finished, so it stays in the request count.
seedChatGatewayRequest(t, db, firstUser.UserID, chat.ID, database.InsertAIBridgeTokenUsageParams{
CostMicros: sql.NullInt64{Int64: 900, Valid: true},
})
ctx := testutil.Context(t, testutil.WaitLong)
cost, err := client.GetChatCost(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, int64(0), cost.TotalCostMicros)
require.Equal(t, int64(1), cost.RequestCount)
require.Equal(t, int64(0), cost.UnpricedRequestCount)
})
t.Run("ExcludesForeignAndUnfinishedRequests", func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_, otherUser := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
modelConfig := createChatModel(t, client)
everyoneGroup := uuid.NullUUID{UUID: firstUser.OrganizationID, Valid: true}
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "owner chat",
})
seedChatGatewayRequest(t, db, otherUser.ID, chat.ID, database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 700, Valid: true},
})
foreignEndedAt := dbtime.Now().Add(time.Second)
foreignInterception := dbgen.AIBridgeInterception(t, db, database.InsertAIBridgeInterceptionParams{
InitiatorID: firstUser.UserID,
StartedAt: dbtime.Now(),
Client: sql.NullString{String: string(aibclient.ClaudeCode), Valid: true},
ClientSessionID: sql.NullString{String: chat.ID.String(), Valid: true},
}, &foreignEndedAt)
dbgen.AIBridgeTokenUsage(t, db, database.InsertAIBridgeTokenUsageParams{
InterceptionID: foreignInterception.ID,
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 800, Valid: true},
})
unfinishedInterception := dbgen.AIBridgeInterception(t, db, database.InsertAIBridgeInterceptionParams{
InitiatorID: firstUser.UserID,
StartedAt: dbtime.Now(),
Client: sql.NullString{String: string(aibclient.CoderAgents), Valid: true},
ClientSessionID: sql.NullString{String: chat.ID.String(), Valid: true},
}, nil)
dbgen.AIBridgeTokenUsage(t, db, database.InsertAIBridgeTokenUsageParams{
InterceptionID: unfinishedInterception.ID,
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 600, Valid: true},
})
ctx := testutil.Context(t, testutil.WaitLong)
cost, err := client.GetChatCost(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, int64(0), cost.TotalCostMicros)
require.Equal(t, int64(0), cost.RequestCount)
})
t.Run("MemberCanReadOwnChat", func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
modelConfig := createChatModel(t, client)
everyoneGroup := uuid.NullUUID{UUID: firstUser.OrganizationID, Valid: true}
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: member.ID,
LastModelConfigID: modelConfig.ID,
Title: "member chat",
})
seedChatGatewayRequest(t, db, member.ID, chat.ID, database.InsertAIBridgeTokenUsageParams{
EffectiveGroupID: everyoneGroup,
CostMicros: sql.NullInt64{Int64: 450, Valid: true},
})
ctx := testutil.Context(t, testutil.WaitLong)
cost, err := memberClient.GetChatCost(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, chat.ID, cost.ChatID)
require.Equal(t, int64(450), cost.TotalCostMicros)
require.Equal(t, int64(1), cost.RequestCount)
})
t.Run("MemberCannotReadOtherUsersChat", func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "owner chat",
})
ctx := testutil.Context(t, testutil.WaitLong)
_, err := memberClient.GetChatCost(ctx, chat.ID)
require.Error(t, err)
var sdkErr *codersdk.Error
require.ErrorAs(t, err, &sdkErr)
require.Equal(t, http.StatusNotFound, sdkErr.StatusCode())
})
t.Run("ZeroRequests", func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// An ungrouped aggregate always returns a row, so a chat with no
// gateway requests reports zeros instead of failing.
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "empty chat",
})
ctx := testutil.Context(t, testutil.WaitLong)
cost, err := client.GetChatCost(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, chat.ID, cost.ChatID)
require.Equal(t, int64(0), cost.TotalCostMicros)
require.Equal(t, int64(0), cost.RequestCount)
require.Equal(t, int64(0), cost.UnpricedRequestCount)
})
}
func TestWatchChatDesktop(t *testing.T) {
t.Parallel()
t.Run("NoWorkspace", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
createdChat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: "desktop no workspace test",
},
},
})
require.NoError(t, err)
// Try to connect to the desktop endpoint — should fail because
// chat has no workspace.
res, err := client.Request(
ctx,
http.MethodGet,
fmt.Sprintf("/api/experimental/chats/%s/stream/desktop", createdChat.ID),
nil,
)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusBadRequest, res.StatusCode)
})
}
// TestWatchChatGitAuthz is the regression test for CODAGT-184. The
// git-watcher handler opens a bidirectional websocket into the
// workspace agent and streams repository diffs; before the fix it only
// enforced chat:read, so a chat owner who lost workspace SSH /
// application-connect access (e.g. by being demoted from owner to
// template-admin after the chat was bound) could keep exfiltrating
// repository contents.
//
// Other behaviors (no-workspace 400, websocket proxy plumbing,
// disconnected-agent 400) are covered by the mock-based TestWatchChatGit
// in coderd/workspaceagents_internal_test.go.
func TestWatchChatGitAuthz(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
// adminClient = first user (site: owner). Creates the chat below
// and is demoted after the chat is bound.
adminClient, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
_ = createChatModel(t, adminClient)
// A second owner is needed to run UpdateUserRoles on the first
// user, since the server refuses self-demotion.
secondAdminClient, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID, rbac.RoleOwner())
// The workspace owner is a distinct user so that stripping
// adminClient's site roles fully removes its workspace
// SSH/ApplicationConnect. If the workspace were owned by
// adminClient, the user would retain SSH via the org-member role
// regardless of site-role demotion.
_, workspaceOwner := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
workspaceBuild := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: firstUser.OrganizationID,
OwnerID: workspaceOwner.ID,
}).WithAgent().Do()
chat, err := adminClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{Type: codersdk.ChatInputPartTypeText, Text: "codagt-184"},
},
})
require.NoError(t, err)
// Bind the chat to the workspace while adminClient still has
// site-wide workspace:ssh via the owner role.
err = adminClient.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
WorkspaceID: &workspaceBuild.Workspace.ID,
})
require.NoError(t, err)
// Demote adminClient to template-admin. Membership still allows reading this
// chat, so ExtractChatParam passes before workspace authorization fails.
_, err = secondAdminClient.UpdateUserRoles(ctx, firstUser.UserID.String(), codersdk.UpdateRoles{
Roles: []string{rbac.RoleTemplateAdmin().String()},
})
require.NoError(t, err)
res, err := adminClient.Request(
ctx,
http.MethodGet,
fmt.Sprintf("/api/v2/chats/%s/stream/git", chat.ID),
nil,
)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusForbidden, res.StatusCode)
}
func createAIProviderForTest(
t testing.TB,
client *codersdk.ExperimentalClient,
provider string,
apiKey string,
) codersdk.AIProvider {
t.Helper()
ctx := testutil.Context(t, testutil.WaitLong)
baseURL := aiProviderBaseURLForTest(provider)
// AI Gateway routing uses the provider's BaseURL from the DB row.
// For OpenAI-compatible providers, use a real mock server so the
// daemon can route chat requests. Other provider types (anthropic,
// bedrock, google) are only used for model config CRUD tests that
// never process chats through the daemon.
if provider == "openai" || provider == "openai-compat" {
baseURL = chattest.OpenAI(t)
}
req := codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderType(provider),
Name: "test-" + provider + "-" + uuid.NewString(),
BaseURL: baseURL,
Enabled: true,
}
if apiKey != "" {
req.APIKeys = []string{apiKey}
}
aiProvider, err := client.CreateAIProvider(ctx, req)
require.NoError(t, err)
return aiProvider
}
func aiProviderBaseURLForTest(provider string) string {
switch provider {
case "anthropic", "bedrock", "google":
return "https://api.example.com"
default:
return "https://api.example.com/v1"
}
}
// seedManualTitleSourceMessage inserts a visible user message so manual
// title generation has content to summarize.
func seedManualTitleSourceMessage(
t testing.TB,
db database.Store,
chat database.Chat,
modelConfigID uuid.UUID,
) {
t.Helper()
content, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("manual title source"),
})
require.NoError(t, err)
_ = dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
CreatedBy: uuid.NullUUID{UUID: chat.OwnerID, Valid: true},
ModelConfigID: uuid.NullUUID{UUID: modelConfigID, Valid: true},
Role: database.ChatMessageRoleUser,
Visibility: database.ChatMessageVisibilityBoth,
Content: content,
})
}
// seedPasteOnlyTitleSourceMessage inserts a user message whose only
// content is a synthetic pasted-text attachment, mirroring a chat
// created from a large paste with no typed text.
func seedPasteOnlyTitleSourceMessage(
ctx context.Context,
t testing.TB,
db database.Store,
chat database.Chat,
modelConfigID uuid.UUID,
pasteContent string,
) {
t.Helper()
const pasteFileName = "pasted-text-2026-01-02-03-04-05.txt"
file, err := db.InsertChatFile(dbauthz.AsSystemRestricted(ctx), database.InsertChatFileParams{
OwnerID: chat.OwnerID,
OrganizationID: chat.OrganizationID,
Name: pasteFileName,
Mimetype: "text/plain",
Data: []byte(pasteContent),
})
require.NoError(t, err)
content, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
codersdk.ChatMessageFile(file.ID, "text/plain", pasteFileName),
})
require.NoError(t, err)
_ = dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
CreatedBy: uuid.NullUUID{UUID: chat.OwnerID, Valid: true},
ModelConfigID: uuid.NullUUID{UUID: modelConfigID, Valid: true},
Role: database.ChatMessageRoleUser,
Visibility: database.ChatMessageVisibilityBoth,
Content: content,
})
}
// createTitleGenerationChatModel provisions a model config on the openai
// provider type, which routes structured title generation through the
// Responses API. The chattest fake answers it with {"title": "Test Chat"}.
func createTitleGenerationChatModel(
t *testing.T,
client *codersdk.ExperimentalClient,
) codersdk.ChatModel {
t.Helper()
return createAdditionalChatModel(t, client, "openai", "gpt-4.1")
}
// seedChatWithDeletedModelConfig creates a chat whose only model config is
// soft-deleted, leaving the deployment without a usable model config. The
// config exists only to satisfy the chats foreign key.
func seedChatWithDeletedModelConfig(
ctx context.Context,
t *testing.T,
db database.Store,
user codersdk.CreateFirstUserResponse,
) database.Chat {
t.Helper()
modelConfig := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{})
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "chat without model config",
})
seedManualTitleSourceMessage(t, db, chat, modelConfig.ID)
// The fixture's soft-delete runs under an owner subject authorized to
// delete the config, not a shared internal actor.
_, err := db.DeleteChatModelConfigByID(
dbauthz.As(ctx, rbac.Subject{
ID: user.UserID.String(),
Roles: rbac.RoleIdentifiers{rbac.RoleOwner()},
Scope: rbac.ScopeAll,
}),
modelConfig.ID,
)
require.NoError(t, err)
return chat
}
func createChatModel(t testing.TB, client *codersdk.ExperimentalClient) codersdk.ChatModel {
t.Helper()
return coderdtest.CreateOpenAICompatChatModel(t, client, "")
}
func waitForChatStatus(ctx context.Context, t testing.TB, client *codersdk.ExperimentalClient, chatID uuid.UUID, want codersdk.ChatStatus) {
t.Helper()
testutil.Eventually(ctx, t, func(ctx context.Context) bool {
chat, err := client.GetChat(ctx, chatID)
return err == nil && chat.Status == want
}, testutil.IntervalFast, "chat did not reach status %s", want)
}
// chatTab models the state a web client tab keeps for one chat: the IDs
// of the messages it holds and its snapshot version.
type chatTab struct {
ids map[int64]bool
snapshotVersion int64
// withoutSnapshotVersion opens the stream without snapshot_version, as
// clients that predate it do.
withoutSnapshotVersion bool
}
func newChatTab(page codersdk.ChatMessagesResponse) *chatTab {
tab := &chatTab{ids: map[int64]bool{}, snapshotVersion: page.SnapshotVersion}
tab.hold(page.Messages...)
return tab
}
func (tab *chatTab) hold(messages ...codersdk.ChatMessage) {
for _, m := range messages {
tab.ids[m.ID] = true
}
}
func (tab *chatTab) sortedIDs() []int64 {
return slices.Sorted(maps.Keys(tab.ids))
}
// connect opens the stream with the tab's newest message ID and snapshot
// version, and applies events through the status event, which every initial
// sync sends after its versioned events.
func (tab *chatTab) connect(ctx context.Context, t *testing.T, client *codersdk.ExperimentalClient, chatID uuid.UUID) ([]codersdk.ChatStreamEvent, <-chan codersdk.ChatStreamEvent) {
t.Helper()
afterID := slices.Max(append(tab.sortedIDs(), 0))
opts := &codersdk.StreamChatOptions{AfterID: &afterID}
if !tab.withoutSnapshotVersion {
opts.SnapshotVersion = tab.snapshotVersion
}
events, closer, err := client.StreamChat(ctx, chatID, opts)
require.NoError(t, err)
t.Cleanup(func() { _ = closer.Close() })
applied := tab.applyUntil(ctx, t, events, func(event codersdk.ChatStreamEvent) bool {
return event.Type == codersdk.ChatStreamEventTypeStatus
})
return applied, events
}
// applyUntil fails the test if the stream closes or ctx expires before done
// returns true.
func (tab *chatTab) applyUntil(ctx context.Context, t *testing.T, events <-chan codersdk.ChatStreamEvent, done func(codersdk.ChatStreamEvent) bool) []codersdk.ChatStreamEvent {
t.Helper()
var applied []codersdk.ChatStreamEvent
progress := func() string {
types := make([]codersdk.ChatStreamEventType, 0, len(applied))
for _, event := range applied {
types = append(types, event.Type)
}
return fmt.Sprintf("applied %v, snapshot version %d", types, tab.snapshotVersion)
}
for {
select {
case <-ctx.Done():
require.FailNow(t, "timed out applying stream events", progress())
case event, ok := <-events:
if !ok {
require.FailNow(t, "stream closed early", progress())
}
applied = append(applied, event)
tab.snapshotVersion = max(tab.snapshotVersion, event.SnapshotVersion)
switch event.Type {
case codersdk.ChatStreamEventTypeHistoryReset:
var fromID int64
if event.HistoryReset != nil {
fromID = event.HistoryReset.FromMessageID
}
maps.DeleteFunc(tab.ids, func(id int64, _ bool) bool { return id >= fromID })
case codersdk.ChatStreamEventTypeMessage:
tab.hold(*event.Message)
}
if done(event) {
return applied
}
}
}
}
// sendChatMessage sends text, waits for the chat to return to waiting,
// and returns the messages in the response.
func sendChatMessage(ctx context.Context, t *testing.T, client *codersdk.ExperimentalClient, chatID uuid.UUID, text string) []codersdk.ChatMessage {
t.Helper()
resp, err := client.CreateChatMessage(ctx, chatID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: text}},
})
require.NoError(t, err)
require.False(t, resp.Queued)
waitForChatStatus(ctx, t, client, chatID, codersdk.ChatStatusWaiting)
if len(resp.Messages) > 0 {
return resp.Messages
}
require.NotNil(t, resp.Message)
return []codersdk.ChatMessage{*resp.Message}
}
func liveChatMessageIDs(ctx context.Context, t *testing.T, client *codersdk.ExperimentalClient, chatID uuid.UUID) []int64 {
t.Helper()
page, err := client.GetChatMessages(ctx, chatID, nil)
require.NoError(t, err)
require.False(t, page.HasMore)
ids := make([]int64, 0, len(page.Messages))
for _, m := range page.Messages {
ids = append(ids, m.ID)
}
slices.Sort(ids)
return ids
}
// chatStreamReadFailStore fails reads of one chat inside transactions, so
// the stream's first sync fails while the route's read, outside one,
// succeeds.
type chatStreamReadFailStore struct {
database.Store
fail *atomic.Pointer[chatStreamReadFailure]
}
type chatStreamReadFailure struct {
chatID uuid.UUID
err error
}
func (s *chatStreamReadFailStore) InTx(function func(database.Store) error, txOpts *database.TxOptions) error {
return s.Store.InTx(func(tx database.Store) error {
return function(&chatStreamReadFailTx{Store: tx, fail: s.fail})
}, txOpts)
}
type chatStreamReadFailTx struct {
database.Store
fail *atomic.Pointer[chatStreamReadFailure]
}
func (s *chatStreamReadFailTx) GetChatByID(ctx context.Context, id uuid.UUID) (database.Chat, error) {
if failure := s.fail.Load(); failure != nil && failure.chatID == id {
return database.Chat{}, failure.err
}
return s.Store.GetChatByID(ctx, id)
}
// chatStreamSubscribeFailPubsub fails subscriptions to failEvent only, so
// coderd's other subscriptions keep working.
type chatStreamSubscribeFailPubsub struct {
dbpubsub.Pubsub
failEvent atomic.Pointer[string]
}
func (p *chatStreamSubscribeFailPubsub) SubscribeWithErr(event string, listener dbpubsub.ListenerWithErr) (func(), error) {
if failEvent := p.failEvent.Load(); failEvent != nil && *failEvent == event {
return nil, xerrors.New("subscribe failed")
}
return p.Pubsub.SubscribeWithErr(event, listener)
}
func createChatModelWithBaseURL(t testing.TB, client *codersdk.ExperimentalClient, baseURL string) codersdk.ChatModel {
t.Helper()
return coderdtest.CreateOpenAICompatChatModel(t, client, baseURL)
}
// createChatModelWithTitleFailure provisions a model whose streaming chat
// responses succeed, while non-streaming requests fail. The non-streaming path
// is how quick title generation requests structured output, so tests can fail
// title generation without breaking the main assistant response.
func createChatModelWithTitleFailure(t testing.TB, client *codersdk.ExperimentalClient) codersdk.ChatModel {
t.Helper()
baseURL := chattest.NewOpenAI(t, func(req *chattest.OpenAIRequest) chattest.OpenAIResponse {
if req.Stream {
return chattest.OpenAIStreamingResponse(chattest.OpenAITextChunks("Hello from test server.")...)
}
return chattest.OpenAIErrorResponse(http.StatusUnauthorized, "invalid_api_key", "test title failure")
})
return createChatModelWithBaseURL(t, client, baseURL)
}
// createChatModelWithTitleQuotaExhausted provisions a model whose
// non-streaming responses return a provider insufficient_quota error, which
// classifies as a usage limit like an exhausted AI Gateway budget.
func createChatModelWithTitleQuotaExhausted(t testing.TB, client *codersdk.ExperimentalClient) codersdk.ChatModel {
t.Helper()
baseURL := chattest.NewOpenAI(t, func(req *chattest.OpenAIRequest) chattest.OpenAIResponse {
if req.Stream {
return chattest.OpenAIStreamingResponse(chattest.OpenAITextChunks("Hello from test server.")...)
}
return chattest.OpenAIErrorResponse(
http.StatusBadRequest,
"insufficient_quota",
"You exceeded your current quota, please check your plan and billing details.",
)
})
return createChatModelWithBaseURL(t, client, baseURL)
}
func createAdditionalChatModel(
t *testing.T,
client *codersdk.ExperimentalClient,
provider string,
model string,
) codersdk.ChatModel {
t.Helper()
return createAdditionalChatModelWithCallConfig(t, client, provider, model, nil)
}
func createAdditionalChatModelWithReasoningEffort(
t *testing.T,
client *codersdk.ExperimentalClient,
provider string,
model string,
defaultEffort string,
maxEffort string,
) codersdk.ChatModel {
t.Helper()
return createAdditionalChatModelWithCallConfig(t, client, provider, model, &codersdk.ChatModelCallConfig{
ReasoningEffort: &codersdk.ChatModelReasoningEffortConfig{
Default: ptr.Ref(defaultEffort),
Max: ptr.Ref(maxEffort),
},
})
}
func createAdditionalChatModelWithCallConfig(
t *testing.T,
client *codersdk.ExperimentalClient,
provider string,
model string,
modelCallConfig *codersdk.ChatModelCallConfig,
) codersdk.ChatModel {
t.Helper()
ctx := testutil.Context(t, testutil.WaitLong)
aiProvider := createAIProviderForTest(t, client, provider, "test-api-key")
contextLimit := int64(4096)
isDefault := false
defaultOrg, err := client.OrganizationByName(ctx, codersdk.DefaultOrganization)
require.NoError(t, err)
modelConfig, err := client.CreateChatModel(ctx, defaultOrg.ID, codersdk.CreateChatModelRequest{
AIProviderID: &aiProvider.ID,
ContextLimit: &contextLimit,
Model: model,
IsDefault: &isDefault,
ModelConfig: modelCallConfig,
})
require.NoError(t, err)
return modelConfig
}
func createDisabledChatModel(
t *testing.T,
client *codersdk.ExperimentalClient,
provider string,
model string,
) codersdk.ChatModel {
t.Helper()
modelConfig := createAdditionalChatModel(t, client, provider, model)
ctx := testutil.Context(t, testutil.WaitLong)
updated, err := client.UpdateChatModel(ctx, modelConfig.OrganizationID, modelConfig.ID, codersdk.UpdateChatModelRequest{
Enabled: ptr.Ref(false),
})
require.NoError(t, err)
return updated
}
// createProviderDisabledChatModel creates an enabled model config,
// then disables its parent AI provider.
func createProviderDisabledChatModel(
t *testing.T,
client *codersdk.ExperimentalClient,
provider string,
model string,
) codersdk.ChatModel {
t.Helper()
modelConfig := createAdditionalChatModel(t, client, provider, model)
ctx := testutil.Context(t, testutil.WaitLong)
_, err := client.UpdateAIProvider(ctx, modelConfig.AIProviderID.String(), codersdk.UpdateAIProviderRequest{
Enabled: ptr.Ref(false),
})
require.NoError(t, err)
return modelConfig
}
func enableUserChatProviderKey(
t testing.TB,
adminClient *codersdk.ExperimentalClient,
userClient *codersdk.ExperimentalClient,
providerName string,
) codersdk.AIProvider {
t.Helper()
ctx := testutil.Context(t, testutil.WaitLong)
providers, err := adminClient.AIProviders(ctx)
require.NoError(t, err)
var provider codersdk.AIProvider
for _, candidate := range providers {
if candidate.Type == codersdk.AIProviderType(providerName) {
provider = candidate
break
}
}
require.NotEqual(t, uuid.Nil, provider.ID)
_, err = userClient.UpsertUserAIProviderKey(ctx, "me", provider.ID, codersdk.CreateUserAIProviderKeyRequest{
APIKey: "test-user-api-key-" + uuid.NewString(),
})
require.NoError(t, err)
return provider
}
//nolint:tparallel,paralleltest // Subtests share a single coderdtest instance.
func TestChatSystemPrompt(t *testing.T) {
t.Parallel()
adminClient, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
_ = createChatModel(t, adminClient)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
const workspaceAwareness = `This chat started without an attached workspace. Follow subsequent workspace tool results and context for its current state.
Use the conversation and available tools, skills, and MCPs when they are sufficient for the request.
Workspace tools such as execute, read_file, write_file, and edit_files require an attached workspace. If no workspace is attached, create a suitable workspace with create_workspace when missing tools, skills, MCPs, or context prevent progress, or workspace-backed work is needed. Use the workspace's available context and capabilities to continue the user's request. Workspace readiness does not guarantee that skills, MCP tools, or context have finished loading. Use capabilities that are actually exposed, and continue with workspace file and shell tools where possible instead of recreating the workspace.
Requests such as "fix this bug" or "build this app" authorize the workspace setup needed to complete them; the user does not need to request a workspace separately. Do not refuse solely because no workspace is attached. If setup is blocked, explain the specific blocker or required user choice.
Answer questions and self-contained code examples directly when the conversation and available tools are sufficient.
If a workspace is needed, use list_templates before create_workspace and follow its next_step. Call read_template only when you need template parameter or preset details.`
updateChatSystemPrompt := func(t *testing.T, ctx context.Context, req codersdk.UpdateChatSystemPromptRequest) {
t.Helper()
err := adminClient.UpdateChatSystemPrompt(ctx, req)
require.NoError(t, err)
}
getChatSystemPrompt := func(t *testing.T, ctx context.Context) codersdk.ChatSystemPromptResponse {
t.Helper()
resp, err := adminClient.GetChatSystemPrompt(ctx)
require.NoError(t, err)
return resp
}
assertInjectedSystemMessages := func(t *testing.T, ctx context.Context, wantResolvedPrompt string) {
t.Helper()
chat, err := adminClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{
{
Type: codersdk.ChatInputPartTypeText,
Text: fmt.Sprintf("system prompt composition %s", t.Name()),
},
},
})
require.NoError(t, err)
messages, err := db.GetChatMessagesForPromptByChatID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
var systemTexts []string
for _, message := range messages {
if message.Role != database.ChatMessageRoleSystem {
continue
}
parts, err := chatprompt.ParseContent(message)
require.NoError(t, err)
require.Len(t, parts, 1)
require.Equal(t, codersdk.ChatMessagePartTypeText, parts[0].Type)
systemTexts = append(systemTexts, parts[0].Text)
}
if wantResolvedPrompt == "" {
require.Equal(t, []string{workspaceAwareness}, systemTexts)
return
}
require.Equal(t, []string{wantResolvedPrompt, workspaceAwareness}, systemTexts)
}
t.Run("ReturnsEmptyWhenUnset", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
resp := getChatSystemPrompt(t, ctx)
require.Equal(t, "", resp.SystemPrompt)
require.True(t, resp.IncludeDefaultSystemPrompt, "should default to true")
require.Equal(t, chatd.DefaultSystemPrompt, resp.DefaultSystemPrompt, "should return the built-in default prompt for preview")
})
t.Run("AdminCanSet", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
updateChatSystemPrompt(t, ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "You are a helpful coding assistant.",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
resp := getChatSystemPrompt(t, ctx)
require.Equal(t, "You are a helpful coding assistant.", resp.SystemPrompt)
require.True(t, resp.IncludeDefaultSystemPrompt)
require.Equal(t, chatd.DefaultSystemPrompt, resp.DefaultSystemPrompt)
})
t.Run("AdminCanUnset", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
// Unset by sending an empty string.
updateChatSystemPrompt(t, ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
resp := getChatSystemPrompt(t, ctx)
require.Empty(t, resp.SystemPrompt)
require.True(t, resp.IncludeDefaultSystemPrompt)
require.Equal(t, chatd.DefaultSystemPrompt, resp.DefaultSystemPrompt)
})
t.Run("ToggleIncludeDefault", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
updateChatSystemPrompt(t, ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "",
IncludeDefaultSystemPrompt: ptr.Ref(false),
})
resp := getChatSystemPrompt(t, ctx)
require.Empty(t, resp.SystemPrompt)
require.False(t, resp.IncludeDefaultSystemPrompt)
require.Equal(t, chatd.DefaultSystemPrompt, resp.DefaultSystemPrompt)
updateChatSystemPrompt(t, ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
resp = getChatSystemPrompt(t, ctx)
require.Empty(t, resp.SystemPrompt)
require.True(t, resp.IncludeDefaultSystemPrompt)
require.Equal(t, chatd.DefaultSystemPrompt, resp.DefaultSystemPrompt)
})
t.Run("PreservesIncludeDefaultWhenOmitted", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
store := newFailNextChatSystemPromptStore(rawDB)
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
Database: store,
Pubsub: pubsub,
DeploymentValues: coderdtest.DeploymentValues(t),
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
_ = coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
err := client.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "",
IncludeDefaultSystemPrompt: ptr.Ref(false),
})
require.NoError(t, err)
store.failNextGetChatIncludeDefaultSystemPrompt.Store(true)
store.failNextUpsertChatIncludeDefaultSystemPrompt.Store(true)
err = client.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Omitted toggle request",
})
require.NoError(t, err)
resp, err := client.GetChatSystemPrompt(ctx)
require.NoError(t, err)
require.Equal(t, "Omitted toggle request", resp.SystemPrompt)
require.False(t, resp.IncludeDefaultSystemPrompt)
require.Equal(t, chatd.DefaultSystemPrompt, resp.DefaultSystemPrompt)
})
t.Run("ExistingCustomPromptDefaultsIncludeDefaultOff", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
legacyClient, legacyDB := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, legacyClient.Client)
_ = createChatModel(t, legacyClient)
require.NoError(t, legacyDB.UpsertChatSystemPrompt(dbauthz.AsSystemRestricted(ctx), "Legacy custom instructions"))
resp, err := legacyClient.GetChatSystemPrompt(ctx)
require.NoError(t, err)
require.Equal(t, "Legacy custom instructions", resp.SystemPrompt)
require.False(t, resp.IncludeDefaultSystemPrompt)
require.Equal(t, chatd.DefaultSystemPrompt, resp.DefaultSystemPrompt)
chat, err := legacyClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: fmt.Sprintf("legacy custom prompt %s", t.Name()),
}},
})
require.NoError(t, err)
messages, err := legacyDB.GetChatMessagesForPromptByChatID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
var systemTexts []string
for _, message := range messages {
if message.Role != database.ChatMessageRoleSystem {
continue
}
parts, err := chatprompt.ParseContent(message)
require.NoError(t, err)
require.Len(t, parts, 1)
require.Equal(t, codersdk.ChatMessagePartTypeText, parts[0].Type)
systemTexts = append(systemTexts, parts[0].Text)
}
require.Equal(t, []string{"Legacy custom instructions", workspaceAwareness}, systemTexts)
})
t.Run("DefaultSystemPromptPreview", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
resp := getChatSystemPrompt(t, ctx)
require.Equal(t, chatd.DefaultSystemPrompt, resp.DefaultSystemPrompt)
require.NotEmpty(t, resp.DefaultSystemPrompt, "built-in default prompt should not be empty")
})
t.Run("SavesBothFieldsTogether", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
updateChatSystemPrompt(t, ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Custom instructions for all users.",
IncludeDefaultSystemPrompt: ptr.Ref(false),
})
resp := getChatSystemPrompt(t, ctx)
require.Equal(t, "Custom instructions for all users.", resp.SystemPrompt)
require.False(t, resp.IncludeDefaultSystemPrompt)
updateChatSystemPrompt(t, ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Different instructions.",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
resp = getChatSystemPrompt(t, ctx)
require.Equal(t, "Different instructions.", resp.SystemPrompt)
require.True(t, resp.IncludeDefaultSystemPrompt)
})
t.Run("PromptComposition", func(t *testing.T) {
t.Run("DefaultOnlyWhenToggleOnAndEmpty", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
updateChatSystemPrompt(t, ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
resp := getChatSystemPrompt(t, ctx)
require.Empty(t, resp.SystemPrompt)
require.True(t, resp.IncludeDefaultSystemPrompt)
require.Equal(t, chatd.DefaultSystemPrompt, resp.DefaultSystemPrompt)
assertInjectedSystemMessages(t, ctx, chatd.DefaultSystemPrompt)
})
t.Run("BothWhenToggleOnAndNonEmpty", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
updateChatSystemPrompt(t, ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Custom instructions",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
resp := getChatSystemPrompt(t, ctx)
require.Equal(t, "Custom instructions", resp.SystemPrompt)
require.True(t, resp.IncludeDefaultSystemPrompt)
require.Equal(t, chatd.DefaultSystemPrompt, resp.DefaultSystemPrompt)
assertInjectedSystemMessages(t, ctx, chatd.DefaultSystemPrompt+"\n\nCustom instructions")
})
t.Run("CustomOnlyWhenToggleOff", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
updateChatSystemPrompt(t, ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Custom only",
IncludeDefaultSystemPrompt: ptr.Ref(false),
})
resp := getChatSystemPrompt(t, ctx)
require.Equal(t, "Custom only", resp.SystemPrompt)
require.False(t, resp.IncludeDefaultSystemPrompt)
require.Equal(t, chatd.DefaultSystemPrompt, resp.DefaultSystemPrompt)
assertInjectedSystemMessages(t, ctx, "Custom only")
})
t.Run("EmptyWhenToggleOffAndEmpty", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
updateChatSystemPrompt(t, ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "",
IncludeDefaultSystemPrompt: ptr.Ref(false),
})
resp := getChatSystemPrompt(t, ctx)
require.Empty(t, resp.SystemPrompt)
require.False(t, resp.IncludeDefaultSystemPrompt)
require.Equal(t, chatd.DefaultSystemPrompt, resp.DefaultSystemPrompt)
assertInjectedSystemMessages(t, ctx, "")
})
})
t.Run("CreateChatFailsWhenSystemPromptConfigReadFails", func(t *testing.T) {
t.Parallel()
for _, tc := range []struct {
name string
fail func(*failNextChatSystemPromptStore)
}{
{
name: "Deployment",
fail: func(s *failNextChatSystemPromptStore) { s.failNextGetChatSystemPromptConfig.Store(true) },
},
{
name: "Organization",
fail: func(s *failNextChatSystemPromptStore) { s.failNextGetChatOrganizationSystemPrompt.Store(true) },
},
} {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
store := newFailNextChatSystemPromptStore(rawDB)
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
Database: store,
Pubsub: pubsub,
DeploymentValues: coderdtest.DeploymentValues(t),
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
err := client.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Keep custom instructions",
IncludeDefaultSystemPrompt: ptr.Ref(false),
})
require.NoError(t, err)
tc.fail(store)
_, err = client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: fmt.Sprintf("config-read failure %s", t.Name()),
}},
})
requireSDKError(t, err, http.StatusInternalServerError)
chats, err := client.ListChats(ctx, nil)
require.NoError(t, err)
require.Empty(t, chats)
})
}
})
t.Run("NonAdminFails", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
err := memberClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "This should fail.",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
requireSDKError(t, err, http.StatusForbidden)
_, err = memberClient.GetChatSystemPrompt(ctx)
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("UnauthenticatedFails", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
anonClient := codersdk.NewExperimentalClient(codersdk.New(adminClient.URL))
_, err := anonClient.GetChatSystemPrompt(ctx)
var sdkErr *codersdk.Error
require.ErrorAs(t, err, &sdkErr)
require.Equal(t, http.StatusUnauthorized, sdkErr.StatusCode())
})
t.Run("Audit", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
auditClient := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
_ = coderdtest.CreateFirstUser(t, auditClient.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
// A value change emits a Write entry with the setting's stable
// identity.
err := auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "You are a test assistant.",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
require.NoError(t, err)
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.Equal(t, database.AuditActionWrite, logs[0].Action)
require.Equal(t, database.ResourceTypeChatInstructionSettings, logs[0].ResourceType)
require.Equal(t, audit.ChatInstructionSystemPromptID, logs[0].ResourceID)
require.Equal(t, "System prompt", logs[0].ResourceTarget)
require.Equal(t, uuid.Nil, logs[0].OrganizationID)
require.EqualValues(t, http.StatusNoContent, logs[0].StatusCode)
// A value-identical PUT emits nothing (the write still happens).
mAudit.ResetLogs()
err = auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "You are a test assistant.",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
require.NoError(t, err)
require.Empty(t, mAudit.AuditLogs())
resp, err := auditClient.GetChatSystemPrompt(ctx)
require.NoError(t, err)
require.Equal(t, "You are a test assistant.", resp.SystemPrompt)
require.True(t, resp.IncludeDefaultSystemPrompt)
// A second distinct change keeps the same stable identity.
mAudit.ResetLogs()
err = auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Renamed assistant.",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
require.NoError(t, err)
logs = mAudit.AuditLogs()
require.Len(t, logs, 1)
require.Equal(t, audit.ChatInstructionSystemPromptID, logs[0].ResourceID)
require.Equal(t, "System prompt", logs[0].ResourceTarget)
// An omitted-flag PUT is not mis-suppressed: the stored toggle row
// keeps the effective include-default flag false, so a prompt-only
// change still emits an entry.
mAudit.ResetLogs()
err = auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Custom without default.",
IncludeDefaultSystemPrompt: ptr.Ref(false),
})
require.NoError(t, err)
require.Len(t, mAudit.AuditLogs(), 1)
mAudit.ResetLogs()
err = auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Renamed without default.",
})
require.NoError(t, err)
require.Len(t, mAudit.AuditLogs(), 1)
resp, err = auditClient.GetChatSystemPrompt(ctx)
require.NoError(t, err)
require.Equal(t, "Renamed without default.", resp.SystemPrompt)
require.False(t, resp.IncludeDefaultSystemPrompt)
// A failed PUT records the attempt with an empty diff.
mAudit.ResetLogs()
tooLong := strings.Repeat("a", codersdk.DefaultChatMaxPromptBytes+1)
err = auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: tooLong,
})
requireSDKError(t, err, http.StatusBadRequest)
logs = mAudit.AuditLogs()
require.Len(t, logs, 1)
require.EqualValues(t, http.StatusBadRequest, logs[0].StatusCode)
require.JSONEq(t, "{}", string(logs[0].Diff))
})
// A denied PUT records the attempt with status 403, an empty diff, and
// no request body content in the row.
t.Run("AuditDeniedPUTRecordsAttempt", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
auditClient := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, auditClient.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, auditClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
mAudit.ResetLogs()
err := memberClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "must not leak into the audit row",
})
requireSDKError(t, err, http.StatusForbidden)
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.Equal(t, database.ResourceTypeChatInstructionSettings, logs[0].ResourceType)
require.Equal(t, audit.ChatInstructionSystemPromptID, logs[0].ResourceID)
require.Equal(t, "System prompt", logs[0].ResourceTarget)
require.EqualValues(t, http.StatusForbidden, logs[0].StatusCode)
require.JSONEq(t, "{}", string(logs[0].Diff))
require.NotContains(t, string(logs[0].Diff), "must not leak")
})
// A failing upsert rolls the transaction back: the request fails with
// 500, no audit entry is emitted, and the stale Old the failed request
// captured must not poison a later no-change PUT into being audited
// as a change.
t.Run("AuditUpsertFailureThenNoChangeSuppressed", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
store := newFailNextUpsertChatSystemPromptStore(rawDB)
mAudit := audit.NewMock()
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
Database: store,
Pubsub: pubsub,
DeploymentValues: coderdtest.DeploymentValues(t),
Auditor: mAudit,
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
_ = coderdtest.CreateFirstUser(t, client.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
store.failNextUpsertChatSystemPrompt.Store(true)
err := client.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "First prompt.",
IncludeDefaultSystemPrompt: ptr.Ref(false),
})
requireSDKError(t, err, http.StatusInternalServerError)
// The failed request records the attempt with an empty diff.
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.EqualValues(t, http.StatusInternalServerError, logs[0].StatusCode)
require.JSONEq(t, "{}", string(logs[0].Diff))
// The failed write rolled back, so nothing was stored: the stale
// Old from the failed request must not survive into this one, or
// the entry below would diff against "First prompt.". Writing the
// deployment default materializes the override row (absent ->
// explicit true), which the presence field now audits.
mAudit.ResetLogs()
err = client.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
require.NoError(t, err)
logs = mAudit.AuditLogs()
require.Len(t, logs, 1)
require.EqualValues(t, http.StatusNoContent, logs[0].StatusCode)
// With the override row now stored, the identical PUT is a true
// no-op: nothing is audited.
mAudit.ResetLogs()
err = client.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
require.NoError(t, err)
require.Empty(t, mAudit.AuditLogs())
})
// A lock failure rejects the write and records the failed attempt.
t.Run("AuditLockFailureRejectsWrite", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
store := newFailNextAcquireLockStore(rawDB, database.LockIDChatInstructionSystemPrompt)
mAudit := audit.NewMock()
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
Database: store,
Pubsub: pubsub,
DeploymentValues: coderdtest.DeploymentValues(t),
Auditor: mAudit,
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
_ = coderdtest.CreateFirstUser(t, client.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
store.failNextAcquireLock.Store(true)
err := client.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Must not be stored.",
})
requireSDKError(t, err, http.StatusInternalServerError)
resp, err := client.GetChatSystemPrompt(ctx)
require.NoError(t, err)
require.Empty(t, resp.SystemPrompt)
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.EqualValues(t, http.StatusInternalServerError, logs[0].StatusCode)
require.JSONEq(t, "{}", string(logs[0].Diff))
})
// The derived New must match the getter's computed effective state on
// the happy path for every combination of written prompt and
// include-default input, so the derivation cannot drift from
// GetChatSystemPromptConfig's rule.
t.Run("AuditDerivedNewMatchesGetter", func(t *testing.T) {
t.Parallel()
cases := []struct {
name string
prompt string
explicit *bool
}{
{"EmptyPromptOmittedToggle", "", nil},
{"EmptyPromptExplicitTrue", "", ptr.Ref(true)},
{"EmptyPromptExplicitFalse", "", ptr.Ref(false)},
{"NonEmptyPromptOmittedToggle", "Custom instructions.", nil},
{"NonEmptyPromptExplicitTrue", "Custom instructions.", ptr.Ref(true)},
{"NonEmptyPromptExplicitFalse", "Custom instructions.", ptr.Ref(false)},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
auditClient, db := newChatClientWithDatabase(t)
_ = coderdtest.CreateFirstUser(t, auditClient.Client)
err := auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: tc.prompt,
IncludeDefaultSystemPrompt: tc.explicit,
})
require.NoError(t, err)
// The getter's computed state after the write.
stored, err := db.GetChatSystemPromptConfig(dbauthz.AsSystemRestricted(ctx))
require.NoError(t, err)
// The derivation the handler applies, computed from the
// written values and the pre-write stored state (empty
// here, fresh deployment).
newIncludeSet := false
newIncludeValue := true
if tc.explicit != nil {
newIncludeSet = true
newIncludeValue = *tc.explicit
}
if !newIncludeSet {
newIncludeValue = tc.prompt == ""
}
require.Equal(t, tc.prompt, stored.ChatSystemPrompt)
require.Equal(t, newIncludeSet, stored.IncludeDefaultSystemPromptSet,
"derived presence must match the getter")
require.Equal(t, newIncludeValue, stored.IncludeDefaultSystemPrompt,
"derived effective value must match the getter")
})
}
})
// Two concurrent identical PUTs both succeed, but the advisory lock
// makes the second comparison see the first's committed state, so
// only the first write is audited as a change.
// Two concurrent identical PUTs of a new value both succeed, but the
// per-setting lock serializes the Old capture with the write, so the
// first is a real change and the second sees the first's committed
// state and is a no-op: one entry.
t.Run("AuditConcurrentIdenticalPUTsSingleEntry", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
auditClient := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
_ = coderdtest.CreateFirstUser(t, auditClient.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
err := auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Seed prompt.",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
require.NoError(t, err)
require.Len(t, mAudit.AuditLogs(), 1)
mAudit.ResetLogs()
const puts = 2
start := make(chan struct{})
errs := make(chan error, puts)
var wg sync.WaitGroup
for range puts {
wg.Add(1)
go func() {
defer wg.Done()
<-start
errs <- auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Concurrent prompt.",
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
}()
}
close(start)
wg.Wait()
close(errs)
for err := range errs {
require.NoError(t, err)
}
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.Equal(t, database.AuditActionWrite, logs[0].Action)
})
// The audit diff for the fallback flip must carry the re-read boolean,
// not the stale Old value: a regression that built New from the Old
// capture would emit no include_default_system_prompt diff entry. The
// mock's test-supplied diff function pins the captured Old/New pair,
// which the default empty mock diff cannot express.
t.Run("AuditFallbackFlipDiffCarriesReReadValue", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
// This runs on the HTTP handler goroutine (via the deferred
// commitAudit), so it must use assert, not require: require calls
// t.FailNow, which is only legal on the test goroutine.
mAudit := audit.NewMockWithDiffFn(func(old, newVal any) audit.Map {
oldSettings, ok := old.(database.ChatInstructionSettings)
assert.True(t, ok)
newSettings, ok := newVal.(database.ChatInstructionSettings)
assert.True(t, ok)
return audit.Map{
"system_prompt": {Old: oldSettings.SystemPrompt, New: newSettings.SystemPrompt},
"include_default_system_prompt": {Old: oldSettings.IncludeDefaultSystemPrompt, New: newSettings.IncludeDefaultSystemPrompt},
}
})
auditClient := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
_ = coderdtest.CreateFirstUser(t, auditClient.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
// Seed only the prompt key, like a pre-toggle deployment: with no
// include-default row, the effective flag falls back to false
// while a non-empty custom prompt exists.
err := auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Legacy custom instructions.",
})
require.NoError(t, err)
require.Len(t, mAudit.AuditLogs(), 1)
mAudit.ResetLogs()
// Clearing the prompt without sending the flag flips the
// effective include-default value from false to true. The diff
// must show that flip, which is only possible if New came from
// the post-write re-read.
err = auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "",
})
require.NoError(t, err)
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
var diff map[string]codersdk.AuditDiffField
require.NoError(t, json.Unmarshal(logs[0].Diff, &diff))
require.Equal(t, map[string]codersdk.AuditDiffField{
"system_prompt": {Old: "Legacy custom instructions.", New: ""},
"include_default_system_prompt": {Old: false, New: true},
}, diff)
})
t.Run("AuditIncludeDefaultFallbackFlip", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
auditClient := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
_ = coderdtest.CreateFirstUser(t, auditClient.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
// Seed only the prompt key, like a pre-toggle deployment: with no
// include-default row, the effective flag falls back to false
// while a non-empty custom prompt exists.
err := auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "Legacy custom instructions.",
})
require.NoError(t, err)
require.Len(t, mAudit.AuditLogs(), 1)
resp, err := auditClient.GetChatSystemPrompt(ctx)
require.NoError(t, err)
require.Equal(t, "Legacy custom instructions.", resp.SystemPrompt)
require.False(t, resp.IncludeDefaultSystemPrompt)
// Clearing the prompt without sending the flag flips the
// effective include-default value from false to true. The entry
// must be emitted and its diff must carry the boolean change,
// which is why the handler re-reads the pair after writing.
mAudit.ResetLogs()
err = auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "",
})
require.NoError(t, err)
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.Equal(t, database.AuditActionWrite, logs[0].Action)
require.Equal(t, database.ResourceTypeChatInstructionSettings, logs[0].ResourceType)
resp, err = auditClient.GetChatSystemPrompt(ctx)
require.NoError(t, err)
require.Empty(t, resp.SystemPrompt)
require.True(t, resp.IncludeDefaultSystemPrompt)
// Repeating the cleared state changes nothing: no entry.
mAudit.ResetLogs()
err = auditClient.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: "",
})
require.NoError(t, err)
require.Empty(t, mAudit.AuditLogs())
})
}
//nolint:tparallel,paralleltest // Subtests share a single coderdtest instance.
func TestChatPlanModeInstructions(t *testing.T) {
t.Parallel()
adminClient, _ := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
_ = createChatModel(t, adminClient)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
updateChatPlanModeInstructions := func(t *testing.T, ctx context.Context, req codersdk.UpdateChatPlanModeInstructionsRequest) {
t.Helper()
err := adminClient.UpdateChatPlanModeInstructions(ctx, req)
require.NoError(t, err)
}
getChatPlanModeInstructions := func(t *testing.T, ctx context.Context) codersdk.ChatPlanModeInstructionsResponse {
t.Helper()
resp, err := adminClient.GetChatPlanModeInstructions(ctx)
require.NoError(t, err)
return resp
}
roundTripTests := []struct {
name string
updates []string
want string
}{
{
name: "DefaultGETReturnsEmpty",
want: "",
},
{
name: "PUTThenGETRoundTrips",
updates: []string{"Use plan mode for multi-step changes."},
want: "Use plan mode for multi-step changes.",
},
}
for _, tt := range roundTripTests {
t.Run(tt.name, func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
for _, instructions := range tt.updates {
updateChatPlanModeInstructions(t, ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: instructions,
})
}
resp := getChatPlanModeInstructions(t, ctx)
require.Equal(t, tt.want, resp.PlanModeInstructions)
})
}
t.Run("NonAdminGETReturns404", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
_, err := memberClient.GetChatPlanModeInstructions(ctx)
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("Audit", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
auditClient := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
_ = coderdtest.CreateFirstUser(t, auditClient.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
// A value change emits a Write entry with the setting's stable
// identity, distinct from the system prompt's.
err := auditClient.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: "Draft a plan first.",
})
require.NoError(t, err)
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.Equal(t, database.AuditActionWrite, logs[0].Action)
require.Equal(t, database.ResourceTypeChatInstructionSettings, logs[0].ResourceType)
require.Equal(t, audit.ChatInstructionPlanModeID, logs[0].ResourceID)
require.Equal(t, "Plan mode instructions", logs[0].ResourceTarget)
require.NotEqual(t, audit.ChatInstructionSystemPromptID, logs[0].ResourceID)
require.Equal(t, uuid.Nil, logs[0].OrganizationID)
require.EqualValues(t, http.StatusNoContent, logs[0].StatusCode)
// A value-identical PUT emits nothing (the write still happens).
mAudit.ResetLogs()
err = auditClient.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: "Draft a plan first.",
})
require.NoError(t, err)
require.Empty(t, mAudit.AuditLogs())
resp, err := auditClient.GetChatPlanModeInstructions(ctx)
require.NoError(t, err)
require.Equal(t, "Draft a plan first.", resp.PlanModeInstructions)
// A second distinct change keeps the same stable identity.
mAudit.ResetLogs()
err = auditClient.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: "Draft a better plan.",
})
require.NoError(t, err)
logs = mAudit.AuditLogs()
require.Len(t, logs, 1)
require.Equal(t, audit.ChatInstructionPlanModeID, logs[0].ResourceID)
require.Equal(t, "Plan mode instructions", logs[0].ResourceTarget)
// A failed PUT records the attempt with an empty diff.
mAudit.ResetLogs()
tooLong := strings.Repeat("a", codersdk.DefaultChatMaxPromptBytes+1)
err = auditClient.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: tooLong,
})
requireSDKError(t, err, http.StatusBadRequest)
logs = mAudit.AuditLogs()
require.Len(t, logs, 1)
require.EqualValues(t, http.StatusBadRequest, logs[0].StatusCode)
require.JSONEq(t, "{}", string(logs[0].Diff))
})
// A denied PUT records the attempt with status 403, an empty diff, and
// no request body content in the row.
t.Run("AuditDeniedPUTRecordsAttempt", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
auditClient := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, auditClient.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, auditClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
mAudit.ResetLogs()
err := memberClient.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: "must not leak into the audit row",
})
requireSDKError(t, err, http.StatusForbidden)
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.Equal(t, database.ResourceTypeChatInstructionSettings, logs[0].ResourceType)
require.Equal(t, audit.ChatInstructionPlanModeID, logs[0].ResourceID)
require.Equal(t, "Plan mode instructions", logs[0].ResourceTarget)
require.EqualValues(t, http.StatusForbidden, logs[0].StatusCode)
require.JSONEq(t, "{}", string(logs[0].Diff))
require.NotContains(t, string(logs[0].Diff), "must not leak")
})
// A failing upsert rolls the transaction back: the request fails with
// 500, no audit entry is emitted, and the stale Old the failed request
// captured must not poison a later no-change PUT into being audited
// as a change.
t.Run("AuditUpsertFailureThenNoChangeSuppressed", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
store := newFailNextUpsertChatPlanModeInstructionsStore(rawDB)
mAudit := audit.NewMock()
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
Database: store,
Pubsub: pubsub,
DeploymentValues: coderdtest.DeploymentValues(t),
Auditor: mAudit,
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
_ = coderdtest.CreateFirstUser(t, client.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
err := client.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: "Persist me.",
})
require.NoError(t, err)
require.Len(t, mAudit.AuditLogs(), 1)
mAudit.ResetLogs()
store.failNextUpsertChatPlanModeInstructions.Store(true)
err = client.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: "Never stored.",
})
sdkErr := requireSDKError(t, err, http.StatusInternalServerError)
// The transaction error retains the underlying write failure.
require.Contains(t, sdkErr.Detail, "forced plan mode instructions upsert failure")
// The failed request records the attempt with an empty diff.
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.EqualValues(t, http.StatusInternalServerError, logs[0].StatusCode)
require.JSONEq(t, "{}", string(logs[0].Diff))
// The failed write rolled back, so the stored value is still
// "Persist me." and repeating it is a no-op: no entry. The stale
// Old from the failed request must not survive into this one.
mAudit.ResetLogs()
err = client.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: "Persist me.",
})
require.NoError(t, err)
require.Empty(t, mAudit.AuditLogs())
})
// A lock failure rejects the write and records the failed attempt.
t.Run("AuditLockFailureRejectsWrite", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
store := newFailNextAcquireLockStore(rawDB, database.LockIDChatInstructionPlanMode)
mAudit := audit.NewMock()
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
Database: store,
Pubsub: pubsub,
DeploymentValues: coderdtest.DeploymentValues(t),
Auditor: mAudit,
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
_ = coderdtest.CreateFirstUser(t, client.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
store.failNextAcquireLock.Store(true)
err := client.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: "Must not be stored.",
})
requireSDKError(t, err, http.StatusInternalServerError)
resp, err := client.GetChatPlanModeInstructions(ctx)
require.NoError(t, err)
require.Empty(t, resp.PlanModeInstructions)
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.EqualValues(t, http.StatusInternalServerError, logs[0].StatusCode)
require.JSONEq(t, "{}", string(logs[0].Diff))
})
// A baseline read failure rejects the write and records the failed attempt.
t.Run("AuditOldCaptureFailureRejectsWrite", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
store := newFailNextGetChatPlanModeInstructionsStore(rawDB)
mAudit := audit.NewMock()
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
Database: store,
Pubsub: pubsub,
DeploymentValues: coderdtest.DeploymentValues(t),
Auditor: mAudit,
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
_ = coderdtest.CreateFirstUser(t, client.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
store.failNextGetChatPlanModeInstructions.Store(true)
err := client.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: "Must not be stored.",
})
requireSDKError(t, err, http.StatusInternalServerError)
resp, err := client.GetChatPlanModeInstructions(ctx)
require.NoError(t, err)
require.Empty(t, resp.PlanModeInstructions)
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.EqualValues(t, http.StatusInternalServerError, logs[0].StatusCode)
require.JSONEq(t, "{}", string(logs[0].Diff))
})
// A transaction setup failure rejects the write and records the failed attempt.
t.Run("AuditTransactionFailureRejectsWrite", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
store := newFailNextTxStore(rawDB, "chat_plan_mode_instructions_write")
mAudit := audit.NewMock()
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
Database: store,
Pubsub: pubsub,
DeploymentValues: coderdtest.DeploymentValues(t),
Auditor: mAudit,
})
aibridgedtest.StartTestAIBridgeDaemon(t.Context(), t, api, nil)
client := codersdk.NewExperimentalClient(rawClient)
_ = coderdtest.CreateFirstUser(t, client.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
store.failNextTransaction.Store(true)
err := client.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: "Must not be stored.",
})
requireSDKError(t, err, http.StatusInternalServerError)
resp, err := client.GetChatPlanModeInstructions(ctx)
require.NoError(t, err)
require.Empty(t, resp.PlanModeInstructions)
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.EqualValues(t, http.StatusInternalServerError, logs[0].StatusCode)
require.JSONEq(t, "{}", string(logs[0].Diff))
})
t.Run("AuditConcurrentIdenticalPUTsSingleEntry", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
db, pubsub, sqlDB := dbtestutil.NewDBWithSQLDB(t)
mAudit := audit.NewMock()
client := newChatClient(t, func(opts *coderdtest.Options) {
opts.Database = db
opts.Pubsub = pubsub
opts.Auditor = mAudit
})
_ = coderdtest.CreateFirstUser(t, client.Client)
// Discard the login entry emitted by user creation.
mAudit.ResetLogs()
err := client.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: "Seed instructions.",
})
require.NoError(t, err)
require.Len(t, mAudit.AuditLogs(), 1)
// Blocking both PUTs exposes duplicate audits if Old is read before locking.
holding := make(chan struct{})
release := make(chan struct{})
releaseLock := sync.OnceFunc(func() { close(release) })
t.Cleanup(releaseLock)
holderErr := make(chan error, 1)
go func() {
holderErr <- db.InTx(func(tx database.Store) error {
if err := tx.AcquireLock(ctx, database.LockIDChatInstructionPlanMode); err != nil {
return err
}
close(holding)
<-release
return nil
}, nil)
}()
testutil.TryReceive(ctx, t, holding)
// Concurrent identical PUTs of a NEW value under the lock: the
// first is a real change, the second sees the first's committed
// value and is a no-op.
mAudit.ResetLogs()
const puts = 2
errs := make(chan error, puts)
for range puts {
go func() {
errs <- client.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: "Concurrent instructions.",
})
}()
}
testutil.Eventually(ctx, t, func(ctx context.Context) bool {
var waiting int
err := sqlDB.QueryRowContext(ctx, `SELECT count(*) FROM pg_locks
WHERE locktype = 'advisory' AND NOT granted
AND database = (SELECT oid FROM pg_database WHERE datname = current_database())`).Scan(&waiting)
require.NoError(t, err)
return waiting == puts
}, testutil.IntervalFast, "both PUTs wait for the lock")
releaseLock()
require.NoError(t, testutil.TryReceive(ctx, t, holderErr))
for range puts {
require.NoError(t, testutil.TryReceive(ctx, t, errs))
}
require.Len(t, mAudit.AuditLogs(), 1)
})
}
//nolint:tparallel,paralleltest // Context subtests share per-context coderdtest instances.
func TestChatModelOverrides(t *testing.T) {
t.Parallel()
contexts := []codersdk.ChatModelOverrideContext{
codersdk.ChatModelOverrideContextGeneral,
codersdk.ChatModelOverrideContextExplore,
codersdk.ChatModelOverrideContextTitleGeneration,
codersdk.ChatModelOverrideContextCompaction,
codersdk.ChatModelOverrideContextAdvisor,
}
for _, overrideContext := range contexts {
t.Run(string(overrideContext), func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
adminClient, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
defaultModel := createChatModel(t, adminClient)
model := createAdditionalChatModel(t, adminClient, coderdtest.TestChatProviderOpenAICompat, "override-"+string(overrideContext))
reasoningModel := createAdditionalChatModelWithReasoningEffort(
t, adminClient, coderdtest.TestChatProviderOpenAICompat,
"reasoning-"+string(overrideContext), "medium", "high",
)
disabledModel := createDisabledChatModel(t, adminClient, coderdtest.TestChatProviderOpenAICompat, "disabled-"+string(overrideContext))
otherOrg := dbgen.Organization(t, db, database.Organization{IsDefault: false})
otherOrgModel := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: defaultModel.AIProviderID, Valid: true},
Model: "other-org-" + uuid.NewString(),
Enabled: true,
OrganizationID: otherOrg.ID,
})
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
resp, err := adminClient.OrganizationChatModelOverrides(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.Empty(t, resp.Overrides)
updated, err := adminClient.UpdateOrganizationChatModelOverride(ctx, firstUser.OrganizationID, overrideContext, codersdk.UpdateChatModelOverrideRequest{
ModelConfigID: model.ID.String(),
})
require.NoError(t, err)
require.Equal(t, overrideContext, updated.Context)
require.Equal(t, model.ID.String(), updated.ModelConfigID)
require.Nil(t, updated.ReasoningEffort)
stored, err := db.GetChatOrganizationModelOverride(dbauthz.AsSystemRestricted(ctx), database.GetChatOrganizationModelOverrideParams{
OrganizationID: firstUser.OrganizationID,
Context: string(overrideContext),
})
require.NoError(t, err)
require.Equal(t, model.ID, stored.ModelConfigID)
resp, err = adminClient.OrganizationChatModelOverrides(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.Equal(t, []codersdk.ChatModelOverrideResponse{updated}, resp.Overrides)
updated, err = adminClient.UpdateOrganizationChatModelOverride(ctx, firstUser.OrganizationID, overrideContext, codersdk.UpdateChatModelOverrideRequest{
ModelConfigID: reasoningModel.ID.String(),
ReasoningEffort: ptr.Ref("high"),
})
require.NoError(t, err)
require.Equal(t, reasoningModel.ID.String(), updated.ModelConfigID)
require.Equal(t, ptr.Ref("high"), updated.ReasoningEffort)
for _, tc := range []struct {
name string
req codersdk.UpdateChatModelOverrideRequest
}{
{name: "InvalidUUID", req: codersdk.UpdateChatModelOverrideRequest{ModelConfigID: "not-a-uuid"}},
{name: "DisabledModel", req: codersdk.UpdateChatModelOverrideRequest{ModelConfigID: disabledModel.ID.String()}},
{name: "UnknownModel", req: codersdk.UpdateChatModelOverrideRequest{ModelConfigID: uuid.NewString()}},
{name: "OtherOrganization", req: codersdk.UpdateChatModelOverrideRequest{ModelConfigID: otherOrgModel.ID.String()}},
{name: "EffortWithoutModel", req: codersdk.UpdateChatModelOverrideRequest{ReasoningEffort: ptr.Ref("high")}},
{name: "UnsupportedEffort", req: codersdk.UpdateChatModelOverrideRequest{ModelConfigID: model.ID.String(), ReasoningEffort: ptr.Ref("high")}},
{name: "UnselectableEffort", req: codersdk.UpdateChatModelOverrideRequest{ModelConfigID: reasoningModel.ID.String(), ReasoningEffort: ptr.Ref("xhigh")}},
} {
t.Run(tc.name, func(t *testing.T) {
_, err := adminClient.UpdateOrganizationChatModelOverride(ctx, firstUser.OrganizationID, overrideContext, tc.req)
requireSDKError(t, err, http.StatusBadRequest)
})
}
// Org members can read overrides (the personal settings page
// shows effective defaults) but cannot write them.
memberResp, err := memberClient.OrganizationChatModelOverrides(ctx, firstUser.OrganizationID)
require.NoError(t, err)
require.Len(t, memberResp.Overrides, 1)
_, err = memberClient.UpdateOrganizationChatModelOverride(ctx, firstUser.OrganizationID, overrideContext, codersdk.UpdateChatModelOverrideRequest{ModelConfigID: defaultModel.ID.String()})
requireSDKError(t, err, http.StatusNotFound)
cleared, err := adminClient.UpdateOrganizationChatModelOverride(ctx, firstUser.OrganizationID, overrideContext, codersdk.UpdateChatModelOverrideRequest{})
require.NoError(t, err)
require.Equal(t, overrideContext, cleared.Context)
require.Empty(t, cleared.ModelConfigID)
_, err = db.GetChatOrganizationModelOverride(dbauthz.AsSystemRestricted(ctx), database.GetChatOrganizationModelOverrideParams{
OrganizationID: firstUser.OrganizationID,
Context: string(overrideContext),
})
require.ErrorIs(t, err, sql.ErrNoRows)
})
}
t.Run("UnknownContext", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
_, err := adminClient.UpdateOrganizationChatModelOverride(ctx, firstUser.OrganizationID, "not-a-context", codersdk.UpdateChatModelOverrideRequest{})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid chat model override context.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, "general, explore, title_generation, compaction, advisor, computer_use")
})
t.Run("LegacyRoutesRemoved", func(t *testing.T) {
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
coderdtest.CreateFirstUser(t, adminClient.Client)
res, err := adminClient.Request(ctx, http.MethodGet, "/api/v2/chats/config/model-override/general", nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
}
//nolint:tparallel,paralleltest // Subtests share coderdtest instances.
func TestChatModelOverridesComputerUse(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
getRow := func() (database.ChatOrganizationModelOverride, error) {
return db.GetChatOrganizationModelOverride(dbauthz.AsSystemRestricted(ctx), database.GetChatOrganizationModelOverrideParams{
OrganizationID: firstUser.OrganizationID,
Context: string(codersdk.ChatModelOverrideContextComputerUse),
})
}
update := func(req codersdk.UpdateChatModelOverrideRequest) (codersdk.ChatModelOverrideResponse, error) {
return adminClient.UpdateOrganizationChatModelOverride(ctx, firstUser.OrganizationID, codersdk.ChatModelOverrideContextComputerUse, req)
}
// Bedrock providers require Bedrock settings and reject API keys.
createBedrockChatModel := func(t *testing.T, model string) codersdk.ChatModel {
t.Helper()
provider, err := adminClient.CreateAIProvider(ctx, codersdk.CreateAIProviderRequest{
Type: codersdk.AIProviderTypeBedrock,
Name: "test-bedrock-" + uuid.NewString(),
Enabled: true,
BaseURL: "https://bedrock-runtime.us-east-1.amazonaws.com",
Settings: codersdk.AIProviderSettings{
Bedrock: &codersdk.AIProviderBedrockSettings{
Region: "us-east-1",
Model: model,
SmallFastModel: model,
},
},
})
require.NoError(t, err)
contextLimit := int64(4096)
created, err := adminClient.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &provider.ID,
ContextLimit: &contextLimit,
Model: model,
})
require.NoError(t, err)
return created
}
for _, providerType := range []string{"anthropic", "openai"} {
t.Run("Accepts"+providerType, func(t *testing.T) {
model := createAdditionalChatModelWithReasoningEffort(t, adminClient, providerType, "computer-use-"+uuid.NewString(), "medium", "high")
updated, err := update(codersdk.UpdateChatModelOverrideRequest{
ModelConfigID: model.ID.String(),
ReasoningEffort: ptr.Ref("high"),
})
require.NoError(t, err)
require.Equal(t, codersdk.ChatModelOverrideContextComputerUse, updated.Context)
require.Equal(t, model.ID.String(), updated.ModelConfigID)
stored, err := getRow()
require.NoError(t, err)
require.Equal(t, model.ID, stored.ModelConfigID)
require.Equal(t, "high", stored.ReasoningEffort.String)
})
}
t.Run("AcceptsOpenAICompat", func(t *testing.T) {
// An OpenAI-compatible model declares computer use as a function tool,
// so any model on such a provider is selectable for computer use.
model := createAdditionalChatModel(t, adminClient, coderdtest.TestChatProviderOpenAICompat, "computer-use-compat-"+uuid.NewString())
require.Equal(t, codersdk.ChatComputerUseProviderOpenAICompat, model.ComputerUseProvider)
updated, err := update(codersdk.UpdateChatModelOverrideRequest{ModelConfigID: model.ID.String()})
require.NoError(t, err)
require.Equal(t, model.ID.String(), updated.ModelConfigID)
stored, err := getRow()
require.NoError(t, err)
require.Equal(t, model.ID, stored.ModelConfigID)
})
t.Run("RejectsUnsupportedProviderType", func(t *testing.T) {
valid := createAdditionalChatModel(t, adminClient, "anthropic", "computer-use-valid-"+uuid.NewString())
_, err := update(codersdk.UpdateChatModelOverrideRequest{ModelConfigID: valid.ID.String()})
require.NoError(t, err)
before, err := getRow()
require.NoError(t, err)
model := createAdditionalChatModel(t, adminClient, "google", "computer-use-google-"+uuid.NewString())
_, err = update(codersdk.UpdateChatModelOverrideRequest{ModelConfigID: model.ID.String()})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Computer use requires "+chatprovider.ComputerUseModelRequirement+".", sdkErr.Message)
require.Contains(t, sdkErr.Detail, `of type "google"`)
after, err := getRow()
require.NoError(t, err)
require.Equal(t, before.ModelConfigID, after.ModelConfigID)
})
t.Run("AcceptsBedrockClaude", func(t *testing.T) {
model := createBedrockChatModel(t, "us.anthropic.claude-opus-5-5")
require.Equal(t, codersdk.ChatComputerUseProviderAnthropic, model.ComputerUseProvider)
fetched, err := adminClient.ChatModel(ctx, firstUser.OrganizationID, model.ID)
require.NoError(t, err)
require.Equal(t, codersdk.ChatComputerUseProviderAnthropic, fetched.ComputerUseProvider)
patched, err := adminClient.UpdateChatModel(ctx, firstUser.OrganizationID, model.ID, codersdk.UpdateChatModelRequest{DisplayName: "Bedrock Claude"})
require.NoError(t, err)
require.Equal(t, codersdk.ChatComputerUseProviderAnthropic, patched.ComputerUseProvider)
updated, err := update(codersdk.UpdateChatModelOverrideRequest{ModelConfigID: model.ID.String()})
require.NoError(t, err)
require.Equal(t, model.ID.String(), updated.ModelConfigID)
})
t.Run("RejectsBedrockNonClaude", func(t *testing.T) {
model := createBedrockChatModel(t, "openai.gpt-5.4")
require.Empty(t, model.ComputerUseProvider)
_, err := update(codersdk.UpdateChatModelOverrideRequest{ModelConfigID: model.ID.String()})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Computer use requires "+chatprovider.ComputerUseModelRequirement+".", sdkErr.Message)
require.Contains(t, sdkErr.Detail, `of type "bedrock"`)
})
t.Run("RejectsMalformedID", func(t *testing.T) {
_, err := update(codersdk.UpdateChatModelOverrideRequest{ModelConfigID: "not-a-uuid"})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Invalid model_config_id.", sdkErr.Message)
})
t.Run("Clears", func(t *testing.T) {
cleared, err := update(codersdk.UpdateChatModelOverrideRequest{})
require.NoError(t, err)
require.Equal(t, codersdk.ChatModelOverrideContextComputerUse, cleared.Context)
require.Empty(t, cleared.ModelConfigID)
_, err = getRow()
require.ErrorIs(t, err, sql.ErrNoRows)
})
}
func TestChatModelOverridesComputerUseRequiresVirtualDesktopExperiment(t *testing.T) {
t.Parallel()
values := coderdtest.DeploymentValues(t)
values.Experiments = serpent.StringArray{string(codersdk.ExperimentAgentLifecycleHooks)}
adminClient := newChatClientWithDeploymentValues(t, values)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
ctx := testutil.Context(t, testutil.WaitLong)
_, err := adminClient.UpdateOrganizationChatModelOverride(ctx, firstUser.OrganizationID, codersdk.ChatModelOverrideContextComputerUse, codersdk.UpdateChatModelOverrideRequest{})
requireSDKError(t, err, http.StatusNotFound)
// Other contexts stay available without the experiment.
_, err = adminClient.UpdateOrganizationChatModelOverride(ctx, firstUser.OrganizationID, codersdk.ChatModelOverrideContextGeneral, codersdk.UpdateChatModelOverrideRequest{})
require.NoError(t, err)
}
//nolint:tparallel,paralleltest // Subtests share coderdtest instances.
func TestChatPersonalModelOverridesAdminSettings(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
resp, err := adminClient.GetChatPersonalModelOverridesAdminSettings(ctx)
require.NoError(t, err)
require.False(t, resp.AllowUsers)
err = adminClient.UpdateChatPersonalModelOverridesAdminSettings(ctx, codersdk.UpdateChatPersonalModelOverridesAdminSettingsRequest{
AllowUsers: true,
})
require.NoError(t, err)
resp, err = adminClient.GetChatPersonalModelOverridesAdminSettings(ctx)
require.NoError(t, err)
require.True(t, resp.AllowUsers)
err = adminClient.UpdateChatPersonalModelOverridesAdminSettings(ctx, codersdk.UpdateChatPersonalModelOverridesAdminSettingsRequest{
AllowUsers: false,
})
require.NoError(t, err)
resp, err = adminClient.GetChatPersonalModelOverridesAdminSettings(ctx)
require.NoError(t, err)
require.False(t, resp.AllowUsers)
err = memberClient.UpdateChatPersonalModelOverridesAdminSettings(ctx, codersdk.UpdateChatPersonalModelOverridesAdminSettingsRequest{
AllowUsers: true,
})
requireSDKError(t, err, http.StatusForbidden)
_, err = memberClient.GetChatPersonalModelOverridesAdminSettings(ctx)
requireSDKError(t, err, http.StatusNotFound)
}
//nolint:tparallel,paralleltest // Subtests share coderdtest instances.
func TestUserChatPersonalModelOverrides(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
otherMemberClientRaw, otherMember := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
otherMemberClient := codersdk.NewExperimentalClient(otherMemberClientRaw)
defaultModel := createChatModel(t, adminClient)
_ = enableUserChatProviderKey(t, adminClient, memberClient, coderdtest.TestChatProviderOpenAICompat)
modelProvider := createAIProviderForTest(t, adminClient, "anthropic", "")
_, err := memberClient.UpsertUserAIProviderKey(ctx, codersdk.Me, modelProvider.ID, codersdk.CreateUserAIProviderKeyRequest{
APIKey: "test-user-api-key-" + uuid.NewString(),
})
require.NoError(t, err)
contextLimit := int64(4096)
model, err := adminClient.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &modelProvider.ID,
Model: "claude-personal-" + uuid.NewString(),
ContextLimit: &contextLimit,
})
require.NoError(t, err)
reasoningModel, err := adminClient.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &modelProvider.ID,
Model: "claude-personal-reasoning-" + uuid.NewString(),
ContextLimit: &contextLimit,
ModelConfig: &codersdk.ChatModelCallConfig{ReasoningEffort: &codersdk.ChatModelReasoningEffortConfig{
Default: ptr.Ref("medium"),
Max: ptr.Ref("high"),
}},
})
require.NoError(t, err)
disabledModel := createDisabledChatModel(t, adminClient, coderdtest.TestChatProviderOpenAICompat, "disabled-personal-"+uuid.NewString())
otherOrg := dbgen.Organization(t, db, database.Organization{IsDefault: false})
otherOrgModel := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: defaultModel.AIProviderID, Valid: true},
Model: "other-org-personal-" + uuid.NewString(),
Enabled: true,
OrganizationID: otherOrg.ID,
})
_, err = adminClient.UpdateOrganizationChatModelOverride(ctx, firstUser.OrganizationID, codersdk.ChatModelOverrideContextGeneral, codersdk.UpdateChatModelOverrideRequest{ModelConfigID: model.ID.String()})
require.NoError(t, err)
_, err = adminClient.UpdateOrganizationChatModelOverride(ctx, firstUser.OrganizationID, codersdk.ChatModelOverrideContextExplore, codersdk.UpdateChatModelOverrideRequest{ModelConfigID: defaultModel.ID.String()})
require.NoError(t, err)
personalOverride := func(resp codersdk.UserChatPersonalModelOverridesResponse, overrideContext codersdk.ChatPersonalModelOverrideContext) codersdk.ChatPersonalModelOverride {
t.Helper()
switch overrideContext {
case codersdk.ChatPersonalModelOverrideContextRoot:
return resp.Root
case codersdk.ChatPersonalModelOverrideContextGeneral:
return resp.General
case codersdk.ChatPersonalModelOverrideContextExplore:
return resp.Explore
default:
t.Fatalf("unexpected personal model override context %q", overrideContext)
return codersdk.ChatPersonalModelOverride{}
}
}
assertOverride := func(resp codersdk.UserChatPersonalModelOverridesResponse, overrideContext codersdk.ChatPersonalModelOverrideContext, mode codersdk.ChatPersonalModelOverrideMode, modelConfigID string, effort *string, isSet bool) {
t.Helper()
override := personalOverride(resp, overrideContext)
require.Equal(t, overrideContext, override.Context)
require.Equal(t, mode, override.Mode)
require.Equal(t, modelConfigID, override.ModelConfigID)
require.Equal(t, effort, override.ReasoningEffort)
require.Equal(t, isSet, override.IsSet)
}
getRow := func(userID uuid.UUID, organizationID uuid.UUID, overrideContext codersdk.ChatPersonalModelOverrideContext) (database.ChatUserModelOverride, error) {
t.Helper()
return db.GetChatUserModelOverride(dbauthz.AsSystemRestricted(ctx), database.GetChatUserModelOverrideParams{
UserID: userID, OrganizationID: organizationID, Context: string(overrideContext),
})
}
t.Run("DisabledReturnsDefaultsAndRejectsSelfWrite", func(t *testing.T) {
resp, err := memberClient.UserChatPersonalModelOverrides(ctx, firstUser.OrganizationID, codersdk.Me)
require.NoError(t, err)
require.False(t, resp.Enabled)
assertOverride(resp, codersdk.ChatPersonalModelOverrideContextRoot, codersdk.ChatPersonalModelOverrideModeChatDefault, "", nil, false)
assertOverride(resp, codersdk.ChatPersonalModelOverrideContextGeneral, codersdk.ChatPersonalModelOverrideModeDeploymentDefault, "", nil, false)
require.Equal(t, model.ID.String(), resp.DeploymentDefaults.General.ModelConfigID)
require.Equal(t, defaultModel.ID.String(), resp.DeploymentDefaults.Explore.ModelConfigID)
err = memberClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, codersdk.Me, codersdk.ChatPersonalModelOverrideContextRoot, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeChatDefault,
})
requireSDKError(t, err, http.StatusForbidden)
})
t.Run("AdminCanWriteAndReadAnotherUserWhileDisabled", func(t *testing.T) {
err := adminClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, member.ID.String(), codersdk.ChatPersonalModelOverrideContextGeneral, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeDeploymentDefault,
})
require.NoError(t, err)
resp, err := adminClient.UserChatPersonalModelOverrides(ctx, firstUser.OrganizationID, member.ID.String())
require.NoError(t, err)
assertOverride(resp, codersdk.ChatPersonalModelOverrideContextGeneral, codersdk.ChatPersonalModelOverrideModeDeploymentDefault, "", nil, true)
})
err = adminClient.UpdateChatPersonalModelOverridesAdminSettings(ctx, codersdk.UpdateChatPersonalModelOverridesAdminSettingsRequest{AllowUsers: true})
require.NoError(t, err)
t.Run("NonAdminCannotWriteAnotherUser", func(t *testing.T) {
err := memberClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, otherMember.ID.String(), codersdk.ChatPersonalModelOverrideContextGeneral, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeChatDefault,
})
requireSDKError(t, err, http.StatusNotFound)
_, err = otherMemberClient.UserChatPersonalModelOverrides(ctx, firstUser.OrganizationID, codersdk.Me)
require.NoError(t, err)
})
t.Run("ModesRoundTrip", func(t *testing.T) {
for _, overrideContext := range []codersdk.ChatPersonalModelOverrideContext{
codersdk.ChatPersonalModelOverrideContextRoot,
codersdk.ChatPersonalModelOverrideContextGeneral,
codersdk.ChatPersonalModelOverrideContextExplore,
} {
err := memberClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, codersdk.Me, overrideContext, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeModel, ModelConfigID: model.ID.String(),
})
require.NoError(t, err)
}
resp, err := memberClient.UserChatPersonalModelOverrides(ctx, firstUser.OrganizationID, codersdk.Me)
require.NoError(t, err)
require.True(t, resp.Enabled)
for _, overrideContext := range []codersdk.ChatPersonalModelOverrideContext{
codersdk.ChatPersonalModelOverrideContextRoot,
codersdk.ChatPersonalModelOverrideContextGeneral,
codersdk.ChatPersonalModelOverrideContextExplore,
} {
assertOverride(resp, overrideContext, codersdk.ChatPersonalModelOverrideModeModel, model.ID.String(), nil, true)
}
err = memberClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, codersdk.Me, codersdk.ChatPersonalModelOverrideContextGeneral, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeModel, ModelConfigID: reasoningModel.ID.String(), ReasoningEffort: ptr.Ref("high"),
})
require.NoError(t, err)
resp, err = memberClient.UserChatPersonalModelOverrides(ctx, firstUser.OrganizationID, codersdk.Me)
require.NoError(t, err)
assertOverride(resp, codersdk.ChatPersonalModelOverrideContextGeneral, codersdk.ChatPersonalModelOverrideModeModel, reasoningModel.ID.String(), ptr.Ref("high"), true)
for _, overrideContext := range []codersdk.ChatPersonalModelOverrideContext{
codersdk.ChatPersonalModelOverrideContextGeneral,
codersdk.ChatPersonalModelOverrideContextExplore,
} {
err = memberClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, codersdk.Me, overrideContext, codersdk.UpdateUserChatPersonalModelOverrideRequest{Mode: codersdk.ChatPersonalModelOverrideModeDeploymentDefault})
require.NoError(t, err)
}
err = memberClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, codersdk.Me, codersdk.ChatPersonalModelOverrideContextRoot, codersdk.UpdateUserChatPersonalModelOverrideRequest{Mode: codersdk.ChatPersonalModelOverrideModeChatDefault})
require.NoError(t, err)
})
t.Run("ModeValidation", func(t *testing.T) {
cases := []struct {
name string
context codersdk.ChatPersonalModelOverrideContext
req codersdk.UpdateUserChatPersonalModelOverrideRequest
}{
{name: "UnknownMode", context: codersdk.ChatPersonalModelOverrideContextGeneral, req: codersdk.UpdateUserChatPersonalModelOverrideRequest{Mode: "banana"}},
{name: "ModelRequiresID", context: codersdk.ChatPersonalModelOverrideContextGeneral, req: codersdk.UpdateUserChatPersonalModelOverrideRequest{Mode: codersdk.ChatPersonalModelOverrideModeModel}},
{name: "ChatDefaultRejectsID", context: codersdk.ChatPersonalModelOverrideContextRoot, req: codersdk.UpdateUserChatPersonalModelOverrideRequest{Mode: codersdk.ChatPersonalModelOverrideModeChatDefault, ModelConfigID: model.ID.String()}},
{name: "ChatDefaultRejectsEffort", context: codersdk.ChatPersonalModelOverrideContextRoot, req: codersdk.UpdateUserChatPersonalModelOverrideRequest{Mode: codersdk.ChatPersonalModelOverrideModeChatDefault, ReasoningEffort: ptr.Ref("high")}},
{name: "DeploymentDefaultRejectsID", context: codersdk.ChatPersonalModelOverrideContextGeneral, req: codersdk.UpdateUserChatPersonalModelOverrideRequest{Mode: codersdk.ChatPersonalModelOverrideModeDeploymentDefault, ModelConfigID: model.ID.String()}},
{name: "DeploymentDefaultRejectsEffort", context: codersdk.ChatPersonalModelOverrideContextGeneral, req: codersdk.UpdateUserChatPersonalModelOverrideRequest{Mode: codersdk.ChatPersonalModelOverrideModeDeploymentDefault, ReasoningEffort: ptr.Ref("high")}},
{name: "RootRejectsDeploymentDefault", context: codersdk.ChatPersonalModelOverrideContextRoot, req: codersdk.UpdateUserChatPersonalModelOverrideRequest{Mode: codersdk.ChatPersonalModelOverrideModeDeploymentDefault}},
{name: "InvalidUUID", context: codersdk.ChatPersonalModelOverrideContextGeneral, req: codersdk.UpdateUserChatPersonalModelOverrideRequest{Mode: codersdk.ChatPersonalModelOverrideModeModel, ModelConfigID: "not-a-uuid"}},
{name: "UnsupportedEffort", context: codersdk.ChatPersonalModelOverrideContextGeneral, req: codersdk.UpdateUserChatPersonalModelOverrideRequest{Mode: codersdk.ChatPersonalModelOverrideModeModel, ModelConfigID: model.ID.String(), ReasoningEffort: ptr.Ref("high")}},
{name: "UnselectableEffort", context: codersdk.ChatPersonalModelOverrideContextGeneral, req: codersdk.UpdateUserChatPersonalModelOverrideRequest{Mode: codersdk.ChatPersonalModelOverrideModeModel, ModelConfigID: reasoningModel.ID.String(), ReasoningEffort: ptr.Ref("xhigh")}},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
err := memberClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, codersdk.Me, tc.context, tc.req)
requireSDKError(t, err, http.StatusBadRequest)
})
}
})
t.Run("RejectsUnavailableModels", func(t *testing.T) {
for _, modelConfigID := range []string{uuid.NewString(), disabledModel.ID.String(), otherOrgModel.ID.String()} {
err := memberClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, codersdk.Me, codersdk.ChatPersonalModelOverrideContextGeneral, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeModel, ModelConfigID: modelConfigID,
})
requireSDKError(t, err, http.StatusBadRequest)
}
})
t.Run("AdminWriteValidatesWithMemberACL", func(t *testing.T) {
// The admin can read the ACL-restricted model, but the target member
// cannot, and chatd resolves the override under the member's actor.
privateModel := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: defaultModel.AIProviderID, Valid: true},
OrganizationID: firstUser.OrganizationID,
Model: "private-personal-" + uuid.NewString(),
Enabled: true,
GroupACL: database.ChatACL{},
})
err := adminClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, member.ID.String(), codersdk.ChatPersonalModelOverrideContextGeneral, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeModel, ModelConfigID: privateModel.ID.String(),
})
requireSDKError(t, err, http.StatusBadRequest)
// A model the member can use is still accepted from an admin caller.
err = adminClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, member.ID.String(), codersdk.ChatPersonalModelOverrideContextGeneral, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeModel, ModelConfigID: model.ID.String(),
})
require.NoError(t, err)
})
t.Run("OrganizationIsolation", func(t *testing.T) {
dbgen.OrganizationMember(t, db, database.OrganizationMember{OrganizationID: otherOrg.ID, UserID: member.ID})
err := db.UpsertChatUserModelOverride(dbauthz.AsSystemRestricted(ctx), database.UpsertChatUserModelOverrideParams{
UserID: member.ID, OrganizationID: otherOrg.ID, Context: string(codersdk.ChatPersonalModelOverrideContextGeneral),
Mode: string(codersdk.ChatPersonalModelOverrideModeModel), ModelConfigID: uuid.NullUUID{UUID: otherOrgModel.ID, Valid: true},
})
require.NoError(t, err)
orgA, err := memberClient.UserChatPersonalModelOverrides(ctx, firstUser.OrganizationID, codersdk.Me)
require.NoError(t, err)
require.NotEqual(t, otherOrgModel.ID.String(), orgA.General.ModelConfigID)
orgB, err := memberClient.UserChatPersonalModelOverrides(ctx, otherOrg.ID, codersdk.Me)
require.NoError(t, err)
assertOverride(orgB, codersdk.ChatPersonalModelOverrideContextGeneral, codersdk.ChatPersonalModelOverrideModeModel, otherOrgModel.ID.String(), nil, true)
})
t.Run("LegacyRouteRemoved", func(t *testing.T) {
res, err := memberClient.Request(ctx, http.MethodGet, "/api/v2/chats/config/user-personal-model-overrides", nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
_, err = getRow(member.ID, firstUser.OrganizationID, codersdk.ChatPersonalModelOverrideContextRoot)
require.NoError(t, err)
}
//nolint:tparallel,paralleltest // Subtests share coderdtest instances.
func TestCreateChatPersonalModelOverrideRoot(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
defaultModel := createChatModel(t, adminClient)
_ = enableUserChatProviderKey(t, adminClient, adminClient, coderdtest.TestChatProviderOpenAICompat)
overrideProvider := createAIProviderForTest(t, adminClient, "anthropic", "")
_, err := adminClient.UpsertUserAIProviderKey(ctx, "me", overrideProvider.ID, codersdk.CreateUserAIProviderKeyRequest{
APIKey: "test-user-api-key-" + uuid.NewString(),
})
require.NoError(t, err)
contextLimit := int64(4096)
overrideModel, err := adminClient.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &overrideProvider.ID,
Model: "claude-root-personal-" + uuid.NewString(),
ContextLimit: &contextLimit,
})
require.NoError(t, err)
disabledModel := createDisabledChatModel(
t,
adminClient,
coderdtest.TestChatProviderOpenAICompat,
"gpt-4o-root-personal-disabled-"+uuid.NewString(),
)
memberClientRaw, member := coderdtest.CreateAnotherUser(
t,
adminClient.Client,
firstUser.OrganizationID,
)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
createChat := func(
client *codersdk.ExperimentalClient,
text string,
modelConfigID *uuid.UUID,
) codersdk.Chat {
t.Helper()
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: text,
}},
ModelConfigID: modelConfigID,
})
require.NoError(t, err)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Equal(t, chat.LastModelConfigID, storedChat.LastModelConfigID)
return chat
}
upsertRootModel := func(userID uuid.UUID, organizationID uuid.UUID, modelConfigID uuid.UUID) {
t.Helper()
err := db.UpsertChatUserModelOverride(dbauthz.AsSystemRestricted(ctx), database.UpsertChatUserModelOverrideParams{
UserID: userID, OrganizationID: organizationID, Context: string(codersdk.ChatPersonalModelOverrideContextRoot),
Mode: string(codersdk.ChatPersonalModelOverrideModeModel), ModelConfigID: uuid.NullUUID{UUID: modelConfigID, Valid: true},
})
require.NoError(t, err)
}
err = adminClient.UpdateChatPersonalModelOverridesAdminSettings(ctx, codersdk.UpdateChatPersonalModelOverridesAdminSettingsRequest{
AllowUsers: true,
})
require.NoError(t, err)
err = adminClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, codersdk.Me, codersdk.ChatPersonalModelOverrideContextRoot, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeModel,
ModelConfigID: overrideModel.ID.String(),
})
require.NoError(t, err)
t.Run("ExplicitModelConfigWins", func(t *testing.T) {
chat := createChat(adminClient, "explicit model config wins", ptr.Ref(defaultModel.ID))
require.Equal(t, defaultModel.ID, chat.LastModelConfigID)
})
t.Run("FlagOffIgnoresSavedRootModel", func(t *testing.T) {
err := adminClient.UpdateChatPersonalModelOverridesAdminSettings(ctx, codersdk.UpdateChatPersonalModelOverridesAdminSettingsRequest{
AllowUsers: false,
})
require.NoError(t, err)
chat := createChat(adminClient, "flag off uses default", nil)
require.Equal(t, defaultModel.ID, chat.LastModelConfigID)
})
t.Run("ChatDefaultUsesDefaultModel", func(t *testing.T) {
err := adminClient.UpdateChatPersonalModelOverridesAdminSettings(ctx, codersdk.UpdateChatPersonalModelOverridesAdminSettingsRequest{
AllowUsers: true,
})
require.NoError(t, err)
err = adminClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, codersdk.Me, codersdk.ChatPersonalModelOverrideContextRoot, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeChatDefault,
})
require.NoError(t, err)
chat := createChat(adminClient, "chat default uses default", nil)
require.Equal(t, defaultModel.ID, chat.LastModelConfigID)
})
t.Run("UnavailableStoredRootFallsBackToDefault", func(t *testing.T) {
upsertRootModel(firstUser.UserID, firstUser.OrganizationID, disabledModel.ID)
chat := createChat(adminClient, "unavailable root falls back", nil)
require.Equal(t, defaultModel.ID, chat.LastModelConfigID)
})
t.Run("RootModelOverrideUsesSavedModel", func(t *testing.T) {
err := adminClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, codersdk.Me, codersdk.ChatPersonalModelOverrideContextRoot, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeModel,
ModelConfigID: overrideModel.ID.String(),
})
require.NoError(t, err)
chat := createChat(adminClient, "root model override uses saved model", nil)
require.Equal(t, overrideModel.ID, chat.LastModelConfigID)
})
t.Run("RootModelOverrideUsesSavedReasoningEffort", func(t *testing.T) {
reasoningModel, err := adminClient.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &overrideProvider.ID,
Model: "claude-root-personal-reasoning-" + uuid.NewString(),
ContextLimit: &contextLimit,
ModelConfig: &codersdk.ChatModelCallConfig{
ReasoningEffort: &codersdk.ChatModelReasoningEffortConfig{
Default: ptr.Ref("medium"),
Max: ptr.Ref("high"),
},
},
})
require.NoError(t, err)
err = adminClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, codersdk.Me, codersdk.ChatPersonalModelOverrideContextRoot, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeModel,
ModelConfigID: reasoningModel.ID.String(),
ReasoningEffort: ptr.Ref("high"),
})
require.NoError(t, err)
chat := createChat(adminClient, "root model override uses saved reasoning effort", nil)
require.Equal(t, reasoningModel.ID, chat.LastModelConfigID)
require.Equal(t, ptr.Ref("high"), chat.LastReasoningEffort)
})
t.Run("EmptyCreateFirstMessageUsesSavedReasoningEffort", func(t *testing.T) {
reasoningModel, err := adminClient.CreateChatModel(ctx, firstUser.OrganizationID, codersdk.CreateChatModelRequest{
AIProviderID: &overrideProvider.ID,
Model: "claude-root-personal-empty-" + uuid.NewString(),
ContextLimit: &contextLimit,
ModelConfig: &codersdk.ChatModelCallConfig{
ReasoningEffort: &codersdk.ChatModelReasoningEffortConfig{
Default: ptr.Ref("medium"),
Max: ptr.Ref("high"),
},
},
})
require.NoError(t, err)
err = adminClient.UpdateUserChatPersonalModelOverride(ctx, firstUser.OrganizationID, codersdk.Me, codersdk.ChatPersonalModelOverrideContextRoot, codersdk.UpdateUserChatPersonalModelOverrideRequest{
Mode: codersdk.ChatPersonalModelOverrideModeModel,
ModelConfigID: reasoningModel.ID.String(),
ReasoningEffort: ptr.Ref("high"),
})
require.NoError(t, err)
sendFirstMessage := func(modelConfigID *uuid.UUID) database.Chat {
t.Helper()
chat, err := adminClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
})
require.NoError(t, err)
require.Equal(t, reasoningModel.ID, chat.LastModelConfigID)
require.Nil(t, chat.LastReasoningEffort)
_, err = adminClient.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{Type: codersdk.ChatInputPartTypeText, Text: "first message"}},
ModelConfigID: modelConfigID,
})
require.NoError(t, err)
storedChat, err := db.GetChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
return storedChat
}
storedChat := sendFirstMessage(nil)
require.True(t, storedChat.LastReasoningEffort.Valid)
require.Equal(t, database.ChatReasoningEffortHigh, storedChat.LastReasoningEffort.ChatReasoningEffort)
// The override effort belongs to its model, so a send that
// targets another model must not inherit it.
storedChat = sendFirstMessage(ptr.Ref(defaultModel.ID))
require.False(t, storedChat.LastReasoningEffort.Valid)
})
t.Run("CrossOrgRootModelIsUnrepresentable", func(t *testing.T) {
org := dbgen.Organization(t, db, database.Organization{IsDefault: false})
orgModel := dbgen.ChatModelConfig(t, db, database.ChatModelConfig{
AIProviderID: uuid.NullUUID{UUID: defaultModel.AIProviderID, Valid: true},
Model: "org-root-personal-" + uuid.NewString(),
Enabled: true,
IsDefault: true,
OrganizationID: org.ID,
})
otherClientRaw, otherUser := coderdtest.CreateAnotherUser(
t,
adminClient.Client,
org.ID,
)
otherClient := codersdk.NewExperimentalClient(otherClientRaw)
// The composite foreign key makes a root override pointing at
// another organization's model unrepresentable at the schema level.
err := db.UpsertChatUserModelOverride(dbauthz.AsSystemRestricted(ctx), database.UpsertChatUserModelOverrideParams{
UserID: otherUser.ID,
OrganizationID: org.ID,
Context: string(codersdk.ChatPersonalModelOverrideContextRoot),
Mode: string(codersdk.ChatPersonalModelOverrideModeModel),
ModelConfigID: uuid.NullUUID{UUID: overrideModel.ID, Valid: true},
})
require.Error(t, err)
require.True(t, database.IsForeignKeyViolation(err))
chat, err := otherClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: org.ID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "cross-org root model falls back",
}},
})
require.NoError(t, err)
require.Equal(t, orgModel.ID, chat.LastModelConfigID)
})
t.Run("UnavailableRootModelFallsBackToDefault", func(t *testing.T) {
upsertRootModel(firstUser.UserID, firstUser.OrganizationID, disabledModel.ID)
chat := createChat(adminClient, "disabled root model falls back", nil)
require.Equal(t, defaultModel.ID, chat.LastModelConfigID)
upsertRootModel(member.ID, firstUser.OrganizationID, overrideModel.ID)
chat = createChat(memberClient, "missing user key falls back", nil)
require.Equal(t, defaultModel.ID, chat.LastModelConfigID)
})
}
func TestChatDebugLoggingSettings(t *testing.T) {
t.Parallel()
t.Run("DefaultDisabled", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
adminResp, err := adminClient.GetChatDebugLogging(ctx)
require.NoError(t, err)
require.False(t, adminResp.AllowUsers)
require.False(t, adminResp.ForcedByDeployment)
userResp, err := memberClient.GetUserChatDebugLogging(ctx)
require.NoError(t, err)
require.False(t, userResp.DebugLoggingEnabled)
require.False(t, userResp.UserToggleAllowed)
require.False(t, userResp.ForcedByDeployment)
})
t.Run("AdminAllowsUsersToOptIn", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
err := adminClient.UpdateChatDebugLogging(ctx, codersdk.UpdateChatDebugLoggingAllowUsersRequest{
AllowUsers: true,
})
require.NoError(t, err)
userResp, err := memberClient.GetUserChatDebugLogging(ctx)
require.NoError(t, err)
require.False(t, userResp.DebugLoggingEnabled)
require.True(t, userResp.UserToggleAllowed)
require.False(t, userResp.ForcedByDeployment)
err = memberClient.UpdateUserChatDebugLogging(ctx, codersdk.UpdateUserChatDebugLoggingRequest{
DebugLoggingEnabled: true,
})
require.NoError(t, err)
userResp, err = memberClient.GetUserChatDebugLogging(ctx)
require.NoError(t, err)
require.True(t, userResp.DebugLoggingEnabled)
require.True(t, userResp.UserToggleAllowed)
require.False(t, userResp.ForcedByDeployment)
// Admin revocation must flip the user's effective state even
// while the stored opt-in is true. A regression that kept
// returning the stored opt-in would be masked if the user had
// already opted out, so we revoke here before the user touches
// their setting.
err = adminClient.UpdateChatDebugLogging(ctx, codersdk.UpdateChatDebugLoggingAllowUsersRequest{
AllowUsers: false,
})
require.NoError(t, err)
userResp, err = memberClient.GetUserChatDebugLogging(ctx)
require.NoError(t, err)
require.False(t, userResp.DebugLoggingEnabled)
require.False(t, userResp.UserToggleAllowed)
require.False(t, userResp.ForcedByDeployment)
// Re-allowing must restore the previously stored opt-in
// without requiring the user to opt in again.
err = adminClient.UpdateChatDebugLogging(ctx, codersdk.UpdateChatDebugLoggingAllowUsersRequest{
AllowUsers: true,
})
require.NoError(t, err)
userResp, err = memberClient.GetUserChatDebugLogging(ctx)
require.NoError(t, err)
require.True(t, userResp.DebugLoggingEnabled, "stored opt-in must survive an admin allow/revoke cycle")
require.True(t, userResp.UserToggleAllowed)
require.False(t, userResp.ForcedByDeployment)
// User can explicitly opt back out while admin still allows the
// toggle. This exercises the UpsertUserChatDebugLoggingEnabled
// success path for the false value.
err = memberClient.UpdateUserChatDebugLogging(ctx, codersdk.UpdateUserChatDebugLoggingRequest{
DebugLoggingEnabled: false,
})
require.NoError(t, err)
userResp, err = memberClient.GetUserChatDebugLogging(ctx)
require.NoError(t, err)
require.False(t, userResp.DebugLoggingEnabled)
require.True(t, userResp.UserToggleAllowed)
require.False(t, userResp.ForcedByDeployment)
})
t.Run("UserWriteFailsWhenAdminDisabled", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
err := memberClient.UpdateUserChatDebugLogging(ctx, codersdk.UpdateUserChatDebugLoggingRequest{
DebugLoggingEnabled: true,
})
requireSDKError(t, err, http.StatusForbidden)
})
t.Run("NonAdminCannotManageAdminSetting", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
_, err := memberClient.GetChatDebugLogging(ctx)
requireSDKError(t, err, http.StatusNotFound)
err = memberClient.UpdateChatDebugLogging(ctx, codersdk.UpdateChatDebugLoggingAllowUsersRequest{
AllowUsers: true,
})
requireSDKError(t, err, http.StatusForbidden)
})
t.Run("DeploymentForceEnablesDebugLogging", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
values := coderdtest.DeploymentValues(t)
values.AI.Chat.DebugLoggingEnabled = serpent.Bool(true)
adminClient := newChatClientWithDeploymentValues(t, values)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
adminResp, err := adminClient.GetChatDebugLogging(ctx)
require.NoError(t, err)
require.False(t, adminResp.AllowUsers)
require.True(t, adminResp.ForcedByDeployment)
userResp, err := memberClient.GetUserChatDebugLogging(ctx)
require.NoError(t, err)
require.True(t, userResp.DebugLoggingEnabled)
require.False(t, userResp.UserToggleAllowed)
require.True(t, userResp.ForcedByDeployment)
err = memberClient.UpdateUserChatDebugLogging(ctx, codersdk.UpdateUserChatDebugLoggingRequest{
DebugLoggingEnabled: false,
})
requireSDKError(t, err, http.StatusConflict)
})
t.Run("UnauthenticatedUserReadFails", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
coderdtest.CreateFirstUser(t, adminClient.Client)
anonClient := codersdk.NewExperimentalClient(codersdk.New(adminClient.URL))
_, err := anonClient.GetUserChatDebugLogging(ctx)
requireSDKError(t, err, http.StatusUnauthorized)
})
}
// seedChatDebugRun inserts a debug run for a chat, bypassing the chatd
// service so HTTP handlers can be exercised in isolation. Steps are
// inserted separately via seedChatDebugStep.
func seedChatDebugRun(
ctx context.Context,
t *testing.T,
db database.Store,
chatID uuid.UUID,
startedAt time.Time,
) database.ChatDebugRun {
t.Helper()
run, err := db.InsertChatDebugRun(dbauthz.AsSystemRestricted(ctx), database.InsertChatDebugRunParams{
ChatID: chatID,
Kind: string(codersdk.ChatDebugRunKindChatTurn),
Status: string(codersdk.ChatDebugStatusInProgress),
Provider: sql.NullString{String: "openai", Valid: true},
Model: sql.NullString{String: "gpt-4o-mini", Valid: true},
StartedAt: sql.NullTime{Time: startedAt, Valid: true},
UpdatedAt: sql.NullTime{Time: startedAt, Valid: true},
})
require.NoError(t, err)
return run
}
func seedChatDebugStep(
ctx context.Context,
t *testing.T,
db database.Store,
run database.ChatDebugRun,
stepNumber int32,
) database.ChatDebugStep {
t.Helper()
step, err := db.InsertChatDebugStep(dbauthz.AsSystemRestricted(ctx), database.InsertChatDebugStepParams{
RunID: run.ID,
ChatID: run.ChatID,
StepNumber: stepNumber,
Operation: string(codersdk.ChatDebugStepOperationStream),
Status: string(codersdk.ChatDebugStatusCompleted),
})
require.NoError(t, err)
return step
}
func TestChatDebugRuns(t *testing.T) {
t.Parallel()
t.Run("ListReturnsRunsNewestFirst", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: member.ID,
LastModelConfigID: modelConfig.ID,
Title: "debug-runs-list",
})
base := time.Now().UTC().Add(-time.Hour).Round(time.Second)
older := seedChatDebugRun(ctx, t, db, chat.ID, base)
newer := seedChatDebugRun(ctx, t, db, chat.ID, base.Add(10*time.Minute))
runs, err := memberClient.GetChatDebugRuns(ctx, chat.ID)
require.NoError(t, err)
require.Len(t, runs, 2)
require.Equal(t, newer.ID, runs[0].ID, "newest run must come first")
require.Equal(t, older.ID, runs[1].ID)
require.Equal(t, codersdk.ChatDebugRunKindChatTurn, runs[0].Kind)
require.Equal(t, codersdk.ChatDebugStatusInProgress, runs[0].Status)
})
t.Run("ListCapsAt100", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "debug-runs-cap",
})
base := time.Now().UTC().Add(-24 * time.Hour).Round(time.Second)
// Seed 101 runs with monotonically increasing started_at. The
// handler caps at 100, so the oldest run (i=0) must be excluded
// and the remaining runs must be returned newest-first.
seeded := make([]database.ChatDebugRun, 101)
for i := range seeded {
seeded[i] = seedChatDebugRun(ctx, t, db, chat.ID, base.Add(time.Duration(i)*time.Minute))
}
runs, err := client.GetChatDebugRuns(ctx, chat.ID)
require.NoError(t, err)
require.Len(t, runs, 100, "list must be capped at maxDebugRuns")
require.Equal(t, seeded[100].ID, runs[0].ID, "newest seeded run must come first")
require.Equal(t, seeded[1].ID, runs[99].ID, "oldest retained run must be last, proving the cap drops the oldest")
returned := make(map[uuid.UUID]struct{}, len(runs))
for _, r := range runs {
returned[r.ID] = struct{}{}
}
require.NotContains(t, returned, seeded[0].ID, "oldest seeded run must be excluded by the cap")
})
t.Run("ReturnsEmptyListWhenNoRuns", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "debug-runs-empty",
})
// Guard against a regression from `make([]..., 0, n)` to
// `var summaries []...`, which would silently serialize as
// `null` instead of `[]`.
runs, err := client.GetChatDebugRuns(ctx, chat.ID)
require.NoError(t, err)
require.NotNil(t, runs, "runs slice must be non-nil even when empty")
require.Empty(t, runs)
})
t.Run("NonExistentChatReturns404", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
coderdtest.CreateFirstUser(t, client.Client)
_, err := client.GetChatDebugRuns(ctx, uuid.New())
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("NonOwnerCannotList", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Chat owned by the first (admin) user.
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "debug-runs-other-owner",
})
seedChatDebugRun(ctx, t, db, chat.ID, time.Now().UTC())
otherClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
otherClient := codersdk.NewExperimentalClient(otherClientRaw)
_, err := otherClient.GetChatDebugRuns(ctx, chat.ID)
requireSDKError(t, err, http.StatusNotFound)
})
}
func TestChatDebugRun(t *testing.T) {
t.Parallel()
t.Run("ReturnsRunWithSteps", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "debug-run-detail",
})
run := seedChatDebugRun(ctx, t, db, chat.ID, time.Now().UTC())
firstStep := seedChatDebugStep(ctx, t, db, run, 1)
secondStep := seedChatDebugStep(ctx, t, db, run, 2)
got, err := client.GetChatDebugRun(ctx, chat.ID, run.ID)
require.NoError(t, err)
require.Equal(t, run.ID, got.ID)
require.Equal(t, chat.ID, got.ChatID)
require.Equal(t, codersdk.ChatDebugRunKindChatTurn, got.Kind)
require.Equal(t, codersdk.ChatDebugStatusInProgress, got.Status)
require.NotNil(t, got.Provider)
require.Equal(t, "openai", *got.Provider)
require.Len(t, got.Steps, 2)
require.Equal(t, firstStep.ID, got.Steps[0].ID)
require.Equal(t, secondStep.ID, got.Steps[1].ID)
require.Equal(t, codersdk.ChatDebugStepOperationStream, got.Steps[0].Operation)
})
t.Run("ReturnsRunWithoutSteps", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "debug-run-empty",
})
run := seedChatDebugRun(ctx, t, db, chat.ID, time.Now().UTC())
got, err := client.GetChatDebugRun(ctx, chat.ID, run.ID)
require.NoError(t, err)
require.Equal(t, run.ID, got.ID)
require.NotNil(t, got.Steps, "steps slice must be non-nil even when empty")
require.Empty(t, got.Steps)
})
t.Run("InvalidRunIDReturns400", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "debug-run-bad-uuid",
})
// Issue a raw request with a non-UUID run ID to exercise the
// handler's parser path.
res, err := client.Request(ctx, http.MethodGet,
fmt.Sprintf("/api/experimental/chats/%s/debug/runs/not-a-uuid", chat.ID), nil)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusBadRequest, res.StatusCode)
})
t.Run("NonExistentRunReturns404", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "debug-run-missing",
})
_, err := client.GetChatDebugRun(ctx, chat.ID, uuid.New())
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("RunOnOtherChatReturns404", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Two chats owned by the same user. A run on chat A must not
// be addressable through chat B's URL.
chatA := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "debug-run-chat-a",
})
chatB := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "debug-run-chat-b",
})
runOnA := seedChatDebugRun(ctx, t, db, chatA.ID, time.Now().UTC())
_, err := client.GetChatDebugRun(ctx, chatB.ID, runOnA.ID)
requireSDKError(t, err, http.StatusNotFound)
})
}
//nolint:tparallel,paralleltest // Subtests share one server and its advisor configuration.
func TestChatAdvisorConfig(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
// Subtests that change the configuration restore the default when they
// finish, so no subtest depends on the ones that ran before it.
restoreDefault := func(t *testing.T) {
t.Cleanup(func() {
require.NoError(t, db.UpsertChatAdvisorConfig(dbauthz.AsSystemRestricted(ctx), "{}"))
})
}
t.Run("GetDefault", func(t *testing.T) {
resp, err := adminClient.GetChatAdvisorConfig(ctx)
require.NoError(t, err)
require.True(t, resp.Enabled)
require.Zero(t, resp.MaxUsesPerRun)
require.Zero(t, resp.MaxOutputTokens)
})
t.Run("Update", func(t *testing.T) {
restoreDefault(t)
req := codersdk.UpdateAdvisorConfigRequest{MaxUsesPerRun: 5, MaxOutputTokens: 1024}
require.NoError(t, adminClient.UpdateChatAdvisorConfig(ctx, req))
resp, err := adminClient.GetChatAdvisorConfig(ctx)
require.NoError(t, err)
require.Equal(t, codersdk.AdvisorConfig{Enabled: true, MaxUsesPerRun: 5, MaxOutputTokens: 1024}, resp)
})
t.Run("MemberCannotWriteButCanRead", func(t *testing.T) {
restoreDefault(t)
req := codersdk.UpdateAdvisorConfigRequest{MaxUsesPerRun: 2, MaxOutputTokens: 256}
require.NoError(t, adminClient.UpdateChatAdvisorConfig(ctx, req))
requireSDKError(t, memberClient.UpdateChatAdvisorConfig(ctx, req), http.StatusForbidden)
resp, err := memberClient.GetChatAdvisorConfig(ctx)
require.NoError(t, err)
require.Equal(t, codersdk.AdvisorConfig{Enabled: true, MaxUsesPerRun: 2, MaxOutputTokens: 256}, resp)
})
t.Run("NegativeValuesRejected", func(t *testing.T) {
for _, req := range []codersdk.UpdateAdvisorConfigRequest{{MaxUsesPerRun: -1}, {MaxOutputTokens: -1}} {
err := adminClient.UpdateChatAdvisorConfig(ctx, req)
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "non-negative")
}
})
t.Run("OverwriteClearsPreviousValues", func(t *testing.T) {
restoreDefault(t)
require.NoError(t, adminClient.UpdateChatAdvisorConfig(ctx, codersdk.UpdateAdvisorConfigRequest{MaxUsesPerRun: 5, MaxOutputTokens: 1024}))
require.NoError(t, adminClient.UpdateChatAdvisorConfig(ctx, codersdk.UpdateAdvisorConfigRequest{}))
resp, err := adminClient.GetChatAdvisorConfig(ctx)
require.NoError(t, err)
require.Equal(t, codersdk.AdvisorConfig{Enabled: true}, resp)
})
t.Run("IgnoresLegacyReasoningEffort", func(t *testing.T) {
restoreDefault(t)
stored := `{"enabled":true,"max_uses_per_run":3,"max_output_tokens":2048,"reasoning_effort":"high"}`
require.NoError(t, db.UpsertChatAdvisorConfig(dbauthz.AsSystemRestricted(ctx), stored))
resp, err := adminClient.GetChatAdvisorConfig(ctx)
require.NoError(t, err)
require.Equal(t, codersdk.AdvisorConfig{Enabled: true, MaxUsesPerRun: 3, MaxOutputTokens: 2048}, resp)
raw, err := db.GetChatAdvisorConfig(dbauthz.AsSystemRestricted(ctx))
require.NoError(t, err)
require.JSONEq(t, stored, raw)
})
t.Run("UnauthenticatedFails", func(t *testing.T) {
anonClient := codersdk.NewExperimentalClient(codersdk.New(adminClient.URL))
_, err := anonClient.GetChatAdvisorConfig(ctx)
requireSDKError(t, err, http.StatusUnauthorized)
err = anonClient.UpdateChatAdvisorConfig(ctx, codersdk.UpdateAdvisorConfigRequest{})
requireSDKError(t, err, http.StatusUnauthorized)
})
t.Run("CorruptStoredJSONReturnsError", func(t *testing.T) {
restoreDefault(t)
require.NoError(t, db.UpsertChatAdvisorConfig(dbauthz.AsSystemRestricted(ctx), "not-json"))
_, err := adminClient.GetChatAdvisorConfig(ctx)
sdkErr := requireSDKError(t, err, http.StatusInternalServerError)
require.Contains(t, sdkErr.Message, "invalid")
})
}
func TestChatWorkspaceTTL(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
anonClient := codersdk.NewExperimentalClient(codersdk.New(adminClient.URL))
// Default value is 0 (disabled) when nothing has been configured.
resp, err := adminClient.GetChatWorkspaceTTL(ctx)
require.NoError(t, err, "get default")
require.Equal(t, int64(0), resp.WorkspaceTTLMillis, "default should be 0")
// Admin can set a positive TTL (2h = 7_200_000 ms).
err = adminClient.UpdateChatWorkspaceTTL(ctx, codersdk.UpdateChatWorkspaceTTLRequest{
WorkspaceTTLMillis: 7_200_000,
})
require.NoError(t, err, "admin set 2h")
resp, err = adminClient.GetChatWorkspaceTTL(ctx)
require.NoError(t, err, "get after set")
require.Equal(t, int64(7_200_000), resp.WorkspaceTTLMillis, "should return 7200000 ms (2h)")
// Non-admin can read the value.
resp, err = memberClient.GetChatWorkspaceTTL(ctx)
require.NoError(t, err, "member get")
require.Equal(t, int64(7_200_000), resp.WorkspaceTTLMillis, "member should see same value")
// Admin can set back to zero (disabled / template default).
err = adminClient.UpdateChatWorkspaceTTL(ctx, codersdk.UpdateChatWorkspaceTTLRequest{
WorkspaceTTLMillis: 0,
})
require.NoError(t, err, "admin set 0")
resp, err = adminClient.GetChatWorkspaceTTL(ctx)
require.NoError(t, err, "get after zero")
require.Equal(t, int64(0), resp.WorkspaceTTLMillis, "should be 0 after reset")
// Non-admin write is forbidden.
err = memberClient.UpdateChatWorkspaceTTL(ctx, codersdk.UpdateChatWorkspaceTTLRequest{
WorkspaceTTLMillis: 3_600_000,
})
requireSDKError(t, err, http.StatusForbidden)
// Unauthenticated read is rejected.
_, err = anonClient.GetChatWorkspaceTTL(ctx)
var sdkErr *codersdk.Error
require.ErrorAs(t, err, &sdkErr, "anon get")
require.Equal(t, http.StatusUnauthorized, sdkErr.StatusCode(), "anon should get 401")
// Validation: negative duration.
err = adminClient.UpdateChatWorkspaceTTL(ctx, codersdk.UpdateChatWorkspaceTTLRequest{
WorkspaceTTLMillis: -3_600_000,
})
requireSDKError(t, err, http.StatusBadRequest)
// Validation: less than 1 minute (30s = 30_000 ms).
err = adminClient.UpdateChatWorkspaceTTL(ctx, codersdk.UpdateChatWorkspaceTTLRequest{
WorkspaceTTLMillis: 30_000,
})
requireSDKError(t, err, http.StatusBadRequest)
// Boundary: just under 1 minute should be rejected (59_999 ms).
err = adminClient.UpdateChatWorkspaceTTL(ctx, codersdk.UpdateChatWorkspaceTTLRequest{
WorkspaceTTLMillis: 59_999,
})
requireSDKError(t, err, http.StatusBadRequest)
// Boundary: exactly 1 minute should succeed (60_000 ms).
err = adminClient.UpdateChatWorkspaceTTL(ctx, codersdk.UpdateChatWorkspaceTTLRequest{
WorkspaceTTLMillis: 60_000,
})
require.NoError(t, err, "exactly 1 minute should be accepted")
// Boundary: exactly 30 days should succeed (720h = 2_592_000_000 ms).
err = adminClient.UpdateChatWorkspaceTTL(ctx, codersdk.UpdateChatWorkspaceTTLRequest{
WorkspaceTTLMillis: 2_592_000_000,
})
require.NoError(t, err, "720h (exactly 30 days) should be accepted")
// Validation: exceeds 30-day maximum (721h = 2_595_600_000 ms).
err = adminClient.UpdateChatWorkspaceTTL(ctx, codersdk.UpdateChatWorkspaceTTLRequest{
WorkspaceTTLMillis: 2_595_600_000,
})
requireSDKError(t, err, http.StatusBadRequest)
// Validation: a value whose nanosecond count overflows int64 and
// wraps to about 1 minute must be rejected and leave the setting alone.
err = adminClient.UpdateChatWorkspaceTTL(ctx, codersdk.UpdateChatWorkspaceTTLRequest{
WorkspaceTTLMillis: 18_446_744_133_710,
})
requireSDKError(t, err, http.StatusBadRequest)
resp, err = adminClient.GetChatWorkspaceTTL(ctx)
require.NoError(t, err, "get after overflow")
require.Equal(t, int64(2_592_000_000), resp.WorkspaceTTLMillis, "overflowing value must not be stored")
}
func TestChatCreateWorkspace_BindFailureCreatesNoWorkspace(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{})
user := coderdtest.CreateFirstUser(t, rawClient)
tv := dbfake.TemplateVersion(t, api.Database).Seed(database.TemplateVersion{
OrganizationID: user.OrganizationID,
CreatedBy: user.UserID,
}).Do()
// The chat does not exist, so the bind inside the create transaction fails.
_, _, err := coderd.ChatCreateWorkspace(api, ctx, user.UserID, uuid.New(), codersdk.CreateWorkspaceRequest{
TemplateID: tv.Template.ID,
Name: "chat-bind-fails",
})
require.ErrorContains(t, err, "bind chat to workspace")
workspaces, err := rawClient.Workspaces(ctx, codersdk.WorkspaceFilter{Owner: codersdk.Me})
require.NoError(t, err)
require.Empty(t, workspaces.Workspaces)
}
//nolint:tparallel,paralleltest // Subtests share one auditor and coderdtest instance.
func TestChatOperationalSettingsAuditDeniedWrites(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
adminClient := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
writes := map[string]func() error{
"RetentionDays": func() error {
return memberClient.UpdateChatRetentionDays(ctx, codersdk.UpdateChatRetentionDaysRequest{RetentionDays: 90})
},
"DebugRetentionDays": func() error {
return memberClient.UpdateChatDebugRetentionDays(ctx, codersdk.UpdateChatDebugRetentionDaysRequest{DebugRetentionDays: 90})
},
"AutoArchiveDays": func() error {
return memberClient.UpdateChatAutoArchiveDays(ctx, codersdk.UpdateChatAutoArchiveDaysRequest{AutoArchiveDays: 90})
},
"WorkspaceTTL": func() error {
return memberClient.UpdateChatWorkspaceTTL(ctx, codersdk.UpdateChatWorkspaceTTLRequest{WorkspaceTTLMillis: time.Hour.Milliseconds()})
},
"DebugLogging": func() error {
return memberClient.UpdateChatDebugLogging(ctx, codersdk.UpdateChatDebugLoggingAllowUsersRequest{AllowUsers: true})
},
"PersonalModelOverrides": func() error {
return memberClient.UpdateChatPersonalModelOverridesAdminSettings(ctx, codersdk.UpdateChatPersonalModelOverridesAdminSettingsRequest{AllowUsers: true})
},
}
for name, write := range writes {
t.Run(name, func(t *testing.T) {
mAudit.ResetLogs()
err := write()
requireSDKError(t, err, http.StatusForbidden)
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.Equal(t, database.ResourceTypeChatOperationalSettings, logs[0].ResourceType)
require.NotEqual(t, uuid.Nil, logs[0].ResourceID)
require.Empty(t, logs[0].ResourceTarget)
require.EqualValues(t, http.StatusForbidden, logs[0].StatusCode)
require.JSONEq(t, "{}", string(logs[0].Diff))
})
}
}
func TestChatRetentionDays_AuditNoOpSkipsWrite(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
store := newFailNextUpsertChatRetentionDaysStore(rawDB)
mAudit := audit.NewMock()
adminClient := newChatClient(t, func(opts *coderdtest.Options) {
opts.Database = store
opts.Pubsub = pubsub
opts.Auditor = mAudit
})
coderdtest.CreateFirstUser(t, adminClient.Client)
mAudit.ResetLogs()
require.NoError(t, rawDB.UpsertChatRetentionDays(ctx, 47))
store.failNextUpsert.Store(true)
require.NoError(t, adminClient.UpdateChatRetentionDays(ctx, codersdk.UpdateChatRetentionDaysRequest{
RetentionDays: 47,
}))
require.True(t, store.failNextUpsert.Load(), "the no-op request must not execute the upsert")
stored, err := rawDB.GetChatSiteConfigValue(ctx, "agents_chat_retention_days")
require.NoError(t, err)
require.Equal(t, database.GetChatSiteConfigValueRow{Value: "47", Exists: true}, stored)
require.Empty(t, mAudit.AuditLogs())
}
func TestChatRetentionDays_AuditInfrastructureFailureRejectsWrite(t *testing.T) {
t.Parallel()
tests := []struct {
name string
retentionDays int32
store func(database.Store) (database.Store, func())
wantDetail string
}{
{
name: "BaselineRead",
retentionDays: 90,
store: func(db database.Store) (database.Store, func()) {
store := newFailNextGetChatSiteConfigValueStore(db)
return store, func() { store.failNextGetChatSiteConfigValue.Store(true) }
},
wantDetail: "forced chat site configuration read failure",
},
{
name: "Lock",
retentionDays: 90,
store: func(db database.Store) (database.Store, func()) {
store := newFailNextAcquireLockStore(db, database.GenLockID("agents_chat_retention_days"))
return store, func() { store.failNextAcquireLock.Store(true) }
},
wantDetail: "acquire chat operational setting write lock: context deadline exceeded",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawDB, pubsub := dbtestutil.NewDB(t)
store, fail := tt.store(rawDB)
mAudit := audit.NewMock()
adminClient := newChatClient(t, func(opts *coderdtest.Options) {
opts.Database = store
opts.Pubsub = pubsub
opts.Auditor = mAudit
})
coderdtest.CreateFirstUser(t, adminClient.Client)
mAudit.ResetLogs()
before, err := rawDB.GetChatSiteConfigValue(ctx, "agents_chat_retention_days")
require.NoError(t, err)
fail()
err = adminClient.UpdateChatRetentionDays(ctx, codersdk.UpdateChatRetentionDaysRequest{
RetentionDays: tt.retentionDays,
})
sdkErr := requireSDKError(t, err, http.StatusInternalServerError)
require.Equal(t, "Failed to update chat retention days.", sdkErr.Message)
require.Contains(t, sdkErr.Detail, tt.wantDetail)
response, err := adminClient.GetChatRetentionDays(ctx)
require.NoError(t, err)
require.Equal(t, int32(30), response.RetentionDays)
after, err := rawDB.GetChatSiteConfigValue(ctx, "agents_chat_retention_days")
require.NoError(t, err)
require.Equal(t, before, after)
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.EqualValues(t, http.StatusInternalServerError, logs[0].StatusCode)
require.JSONEq(t, "{}", string(logs[0].Diff))
})
}
}
func TestChatRetentionDays_AuditConcurrentIdenticalWritesSingleEntry(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
mAudit := audit.NewMock()
adminClient := newChatClient(t, func(opts *coderdtest.Options) {
opts.Auditor = mAudit
})
coderdtest.CreateFirstUser(t, adminClient.Client)
mAudit.ResetLogs()
const writes = 2
start := make(chan struct{})
errs := make(chan error, writes)
var wg sync.WaitGroup
for range writes {
wg.Add(1)
go func() {
defer wg.Done()
<-start
errs <- adminClient.UpdateChatRetentionDays(ctx, codersdk.UpdateChatRetentionDaysRequest{
RetentionDays: 90,
})
}()
}
close(start)
wg.Wait()
close(errs)
for err := range errs {
require.NoError(t, err)
}
logs := mAudit.AuditLogs()
require.Len(t, logs, 1)
require.Equal(t, database.ResourceTypeChatOperationalSettings, logs[0].ResourceType)
require.Equal(t, database.AuditActionWrite, logs[0].Action)
}
func TestChatRetentionDays(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
// Default value is 30 (days) when nothing has been configured.
resp, err := adminClient.GetChatRetentionDays(ctx)
require.NoError(t, err, "get default")
require.Equal(t, int32(30), resp.RetentionDays, "default should be 30")
// Admin can set retention days to 90.
err = adminClient.UpdateChatRetentionDays(ctx, codersdk.UpdateChatRetentionDaysRequest{
RetentionDays: 90,
})
require.NoError(t, err, "admin set 90")
resp, err = adminClient.GetChatRetentionDays(ctx)
require.NoError(t, err, "get after set")
require.Equal(t, int32(90), resp.RetentionDays, "should return 90")
// Non-admin member can read the value.
resp, err = memberClient.GetChatRetentionDays(ctx)
require.NoError(t, err, "member get")
require.Equal(t, int32(90), resp.RetentionDays, "member should see same value")
// Non-admin member cannot write.
err = memberClient.UpdateChatRetentionDays(ctx, codersdk.UpdateChatRetentionDaysRequest{RetentionDays: 7})
requireSDKError(t, err, http.StatusForbidden)
// Admin can disable purge by setting 0.
err = adminClient.UpdateChatRetentionDays(ctx, codersdk.UpdateChatRetentionDaysRequest{
RetentionDays: 0,
})
require.NoError(t, err, "admin set 0")
resp, err = adminClient.GetChatRetentionDays(ctx)
require.NoError(t, err, "get after zero")
require.Equal(t, int32(0), resp.RetentionDays, "should be 0 after disable")
// Validation: negative value is rejected.
err = adminClient.UpdateChatRetentionDays(ctx, codersdk.UpdateChatRetentionDaysRequest{
RetentionDays: -1,
})
requireSDKError(t, err, http.StatusBadRequest)
// Validation: exceeding the 3650-day maximum is rejected.
err = adminClient.UpdateChatRetentionDays(ctx, codersdk.UpdateChatRetentionDaysRequest{
RetentionDays: 3651, // retentionDaysMaximum + 1; keep in sync with coderd/exp_chats.go.
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Retention days must be between 0 and 3650.", sdkErr.Message)
}
func TestChatDebugRetentionDays(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
// Default value is DefaultChatDebugRetentionDays when nothing has
// been configured.
resp, err := adminClient.GetChatDebugRetentionDays(ctx)
require.NoError(t, err, "get default")
require.Equal(t, codersdk.DefaultChatDebugRetentionDays, resp.DebugRetentionDays, "default should match DefaultChatDebugRetentionDays")
// Admin can set debug retention days to 14.
err = adminClient.UpdateChatDebugRetentionDays(ctx, codersdk.UpdateChatDebugRetentionDaysRequest{
DebugRetentionDays: 14,
})
require.NoError(t, err, "admin set 14")
resp, err = adminClient.GetChatDebugRetentionDays(ctx)
require.NoError(t, err, "get after set")
require.Equal(t, int32(14), resp.DebugRetentionDays, "should return 14")
// Non-admin member can read the value.
memberResp, err := memberClient.GetChatDebugRetentionDays(ctx)
require.NoError(t, err, "member read")
require.Equal(t, int32(14), memberResp.DebugRetentionDays, "member sees same value")
// Non-admin member cannot write.
err = memberClient.UpdateChatDebugRetentionDays(ctx, codersdk.UpdateChatDebugRetentionDaysRequest{DebugRetentionDays: 7})
requireSDKError(t, err, http.StatusForbidden)
// Admin can disable chat debug retention purge by setting 0.
err = adminClient.UpdateChatDebugRetentionDays(ctx, codersdk.UpdateChatDebugRetentionDaysRequest{
DebugRetentionDays: 0,
})
require.NoError(t, err, "admin set 0")
resp, err = adminClient.GetChatDebugRetentionDays(ctx)
require.NoError(t, err, "get after zero")
require.Equal(t, int32(0), resp.DebugRetentionDays, "should be 0 after disable")
// Validation: negative value is rejected.
err = adminClient.UpdateChatDebugRetentionDays(ctx, codersdk.UpdateChatDebugRetentionDaysRequest{
DebugRetentionDays: -1,
})
requireSDKError(t, err, http.StatusBadRequest)
// Validation: exceeding the 3650-day maximum is rejected.
err = adminClient.UpdateChatDebugRetentionDays(ctx, codersdk.UpdateChatDebugRetentionDaysRequest{
DebugRetentionDays: 3651, // chatDebugRetentionDaysMaximum + 1; keep in sync with coderd/exp_chats.go.
})
requireSDKError(t, err, http.StatusBadRequest)
}
func TestChatAutoArchiveDays(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
adminClient := newChatClient(t)
firstUser := coderdtest.CreateFirstUser(t, adminClient.Client)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, adminClient.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
// Default value is DefaultChatAutoArchiveDays (0, disabled) when
// nothing has been configured.
resp, err := adminClient.GetChatAutoArchiveDays(ctx)
require.NoError(t, err, "get default")
require.Equal(t, codersdk.DefaultChatAutoArchiveDays, resp.AutoArchiveDays, "default should match DefaultChatAutoArchiveDays")
// Admin can set auto-archive days to 45.
err = adminClient.UpdateChatAutoArchiveDays(ctx, codersdk.UpdateChatAutoArchiveDaysRequest{
AutoArchiveDays: 45,
})
require.NoError(t, err, "admin set 45")
resp, err = adminClient.GetChatAutoArchiveDays(ctx)
require.NoError(t, err, "get after set")
require.Equal(t, int32(45), resp.AutoArchiveDays, "should return 45")
// Non-admin member can read the value (same as retention days).
memberResp, err := memberClient.GetChatAutoArchiveDays(ctx)
require.NoError(t, err, "member read")
require.Equal(t, int32(45), memberResp.AutoArchiveDays, "member sees same value")
// Non-admin member cannot write.
err = memberClient.UpdateChatAutoArchiveDays(ctx, codersdk.UpdateChatAutoArchiveDaysRequest{AutoArchiveDays: 7})
requireSDKError(t, err, http.StatusForbidden)
// Admin can disable auto-archive by setting 0.
err = adminClient.UpdateChatAutoArchiveDays(ctx, codersdk.UpdateChatAutoArchiveDaysRequest{
AutoArchiveDays: 0,
})
require.NoError(t, err, "admin set 0")
resp, err = adminClient.GetChatAutoArchiveDays(ctx)
require.NoError(t, err, "get after zero")
require.Equal(t, int32(0), resp.AutoArchiveDays, "should be 0 after disable")
// An aggressive value of 1 is accepted (no pre-warn to break).
err = adminClient.UpdateChatAutoArchiveDays(ctx, codersdk.UpdateChatAutoArchiveDaysRequest{
AutoArchiveDays: 1,
})
require.NoError(t, err, "admin set 1")
// Validation: negative value is rejected.
err = adminClient.UpdateChatAutoArchiveDays(ctx, codersdk.UpdateChatAutoArchiveDaysRequest{
AutoArchiveDays: -1,
})
requireSDKError(t, err, http.StatusBadRequest)
// Validation: exceeding the 3650-day maximum is rejected.
err = adminClient.UpdateChatAutoArchiveDays(ctx, codersdk.UpdateChatAutoArchiveDaysRequest{
AutoArchiveDays: 3651, // autoArchiveDaysMaximum + 1; keep in sync with coderd/exp_chats.go.
})
requireSDKError(t, err, http.StatusBadRequest)
}
//nolint:tparallel // subtests share state via client, firstUser, modelConfig
func TestUserChatCompactionThresholds(t *testing.T) {
t.Parallel()
client, _ := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
t.Run("EmptyByDefault", func(t *testing.T) { //nolint:paralleltest // subtests share parent state
ctx := testutil.Context(t, testutil.WaitLong)
thresholds, err := client.GetUserChatCompactionThresholds(ctx)
require.NoError(t, err)
require.Empty(t, thresholds.Thresholds)
})
t.Run("PutAndGet", func(t *testing.T) { //nolint:paralleltest // subtests share parent state
ctx := testutil.Context(t, testutil.WaitLong)
override, err := client.UpdateUserChatCompactionThreshold(ctx, modelConfig.ID, codersdk.UpdateUserChatCompactionThresholdRequest{
ThresholdPercent: 75,
})
require.NoError(t, err)
require.Equal(t, modelConfig.ID, override.ModelConfigID)
require.EqualValues(t, 75, override.ThresholdPercent)
thresholds, err := client.GetUserChatCompactionThresholds(ctx)
require.NoError(t, err)
require.Len(t, thresholds.Thresholds, 1)
require.Equal(t, modelConfig.ID, thresholds.Thresholds[0].ModelConfigID)
require.EqualValues(t, 75, thresholds.Thresholds[0].ThresholdPercent)
})
t.Run("UpsertChangesValue", func(t *testing.T) { //nolint:paralleltest // subtests share parent state
ctx := testutil.Context(t, testutil.WaitLong)
_, err := client.UpdateUserChatCompactionThreshold(ctx, modelConfig.ID, codersdk.UpdateUserChatCompactionThresholdRequest{
ThresholdPercent: 50,
})
require.NoError(t, err)
override, err := client.UpdateUserChatCompactionThreshold(ctx, modelConfig.ID, codersdk.UpdateUserChatCompactionThresholdRequest{
ThresholdPercent: 75,
})
require.NoError(t, err)
require.EqualValues(t, 75, override.ThresholdPercent)
thresholds, err := client.GetUserChatCompactionThresholds(ctx)
require.NoError(t, err)
require.Len(t, thresholds.Thresholds, 1)
require.EqualValues(t, 75, thresholds.Thresholds[0].ThresholdPercent)
})
t.Run("BoundaryValues", func(t *testing.T) { //nolint:paralleltest // subtests share parent state
ctx := testutil.Context(t, testutil.WaitLong)
override, err := client.UpdateUserChatCompactionThreshold(ctx, modelConfig.ID, codersdk.UpdateUserChatCompactionThresholdRequest{
ThresholdPercent: 0,
})
require.NoError(t, err)
require.EqualValues(t, 0, override.ThresholdPercent)
thresholds, err := client.GetUserChatCompactionThresholds(ctx)
require.NoError(t, err)
require.Len(t, thresholds.Thresholds, 1)
require.EqualValues(t, 0, thresholds.Thresholds[0].ThresholdPercent)
override, err = client.UpdateUserChatCompactionThreshold(ctx, modelConfig.ID, codersdk.UpdateUserChatCompactionThresholdRequest{
ThresholdPercent: 100,
})
require.NoError(t, err)
require.EqualValues(t, 100, override.ThresholdPercent)
thresholds, err = client.GetUserChatCompactionThresholds(ctx)
require.NoError(t, err)
require.Len(t, thresholds.Thresholds, 1)
require.EqualValues(t, 100, thresholds.Thresholds[0].ThresholdPercent)
})
t.Run("ValidationRejectsInvalid", func(t *testing.T) { //nolint:paralleltest // subtests share parent state
ctx := testutil.Context(t, testutil.WaitLong)
_, err := client.UpdateUserChatCompactionThreshold(ctx, modelConfig.ID, codersdk.UpdateUserChatCompactionThresholdRequest{
ThresholdPercent: -1,
})
requireSDKError(t, err, http.StatusBadRequest)
_, err = client.UpdateUserChatCompactionThreshold(ctx, modelConfig.ID, codersdk.UpdateUserChatCompactionThresholdRequest{
ThresholdPercent: 101,
})
requireSDKError(t, err, http.StatusBadRequest)
})
t.Run("Delete", func(t *testing.T) { //nolint:paralleltest // subtests share parent state
ctx := testutil.Context(t, testutil.WaitLong)
err := client.DeleteUserChatCompactionThreshold(ctx, modelConfig.ID)
require.NoError(t, err)
thresholds, err := client.GetUserChatCompactionThresholds(ctx)
require.NoError(t, err)
require.Empty(t, thresholds.Thresholds)
})
t.Run("DeleteIdempotent", func(t *testing.T) { //nolint:paralleltest // subtests share parent state
ctx := testutil.Context(t, testutil.WaitLong)
err := client.DeleteUserChatCompactionThreshold(ctx, modelConfig.ID)
require.NoError(t, err)
})
t.Run("NonExistentModelConfig", func(t *testing.T) { //nolint:paralleltest // subtests share parent state
ctx := testutil.Context(t, testutil.WaitLong)
fakeID := uuid.New()
_, err := client.UpdateUserChatCompactionThreshold(ctx, fakeID, codersdk.UpdateUserChatCompactionThresholdRequest{
ThresholdPercent: 50,
})
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("IsolatedPerUser", func(t *testing.T) { //nolint:paralleltest // subtests share parent state
ctx := testutil.Context(t, testutil.WaitLong)
memberClientRaw, _ := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
override, err := client.UpdateUserChatCompactionThreshold(ctx, modelConfig.ID, codersdk.UpdateUserChatCompactionThresholdRequest{
ThresholdPercent: 75,
})
require.NoError(t, err)
require.Equal(t, modelConfig.ID, override.ModelConfigID)
require.EqualValues(t, 75, override.ThresholdPercent)
adminThresholds, err := client.GetUserChatCompactionThresholds(ctx)
require.NoError(t, err)
require.Len(t, adminThresholds.Thresholds, 1)
require.Equal(t, modelConfig.ID, adminThresholds.Thresholds[0].ModelConfigID)
require.EqualValues(t, 75, adminThresholds.Thresholds[0].ThresholdPercent)
memberThresholds, err := memberClient.GetUserChatCompactionThresholds(ctx)
require.NoError(t, err)
require.Empty(t, memberThresholds.Thresholds)
})
}
func TestGetChatsByWorkspace(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Helper to create a workspace owned by the test user.
newWorkspace := func() dbfake.WorkspaceBuildBuilder {
return dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
}).WithAgent()
}
// Helper to insert a chat linked to a workspace.
insertChat := func(ctx context.Context, title string, workspaceID uuid.UUID) database.Chat {
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: title,
WorkspaceID: uuid.NullUUID{UUID: workspaceID, Valid: true},
})
return chat
}
t.Run("EmptyRequestReturnsEmptyMap", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
result, err := client.GetChatsByWorkspace(ctx, []uuid.UUID{})
require.NoError(t, err)
require.Empty(t, result)
})
t.Run("WorkspaceWithNoChatsOmitted", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
ws := newWorkspace().Do()
result, err := client.GetChatsByWorkspace(ctx, []uuid.UUID{ws.Workspace.ID})
require.NoError(t, err)
require.Empty(t, result)
})
t.Run("ReturnsChatLinkedToWorkspace", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
ws := newWorkspace().Do()
chat := insertChat(ctx, "workspace chat", ws.Workspace.ID)
result, err := client.GetChatsByWorkspace(ctx, []uuid.UUID{ws.Workspace.ID})
require.NoError(t, err)
require.Len(t, result, 1)
require.Equal(t, chat.ID, result[ws.Workspace.ID])
})
t.Run("ArchivedChatsExcluded", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
ws := newWorkspace().Do()
chat := insertChat(ctx, "soon to be archived", ws.Workspace.ID)
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)})
require.NoError(t, err)
result, err := client.GetChatsByWorkspace(ctx, []uuid.UUID{ws.Workspace.ID})
require.NoError(t, err)
require.Empty(t, result)
})
t.Run("ReturnsLatestNonArchivedChat", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
ws := newWorkspace().Do()
// Insert an older chat and archive it.
olderChat := insertChat(ctx, "older archived", ws.Workspace.ID)
err := client.UpdateChat(ctx, olderChat.ID, codersdk.UpdateChatRequest{Archived: ptr.Ref(true)})
require.NoError(t, err)
// Insert two active chats — the second is newer due to insert
// ordering and should win the "latest" selection in Go after
// the SQL returns both ordered by updated_at DESC.
_ = insertChat(ctx, "older active", ws.Workspace.ID)
newerChat := insertChat(ctx, "newer active", ws.Workspace.ID)
result, err := client.GetChatsByWorkspace(ctx, []uuid.UUID{ws.Workspace.ID})
require.NoError(t, err)
require.Len(t, result, 1)
require.Equal(t, newerChat.ID, result[ws.Workspace.ID])
})
t.Run("MultipleWorkspaces", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
wsA := newWorkspace().Do()
wsB := newWorkspace().Do()
wsC := newWorkspace().Do()
chatA := insertChat(ctx, "chat for workspace A", wsA.Workspace.ID)
chatB := insertChat(ctx, "chat for workspace B", wsB.Workspace.ID)
// Query all three workspaces; C has no chats.
result, err := client.GetChatsByWorkspace(ctx, []uuid.UUID{
wsA.Workspace.ID,
wsB.Workspace.ID,
wsC.Workspace.ID,
})
require.NoError(t, err)
require.Len(t, result, 2)
require.Equal(t, chatA.ID, result[wsA.Workspace.ID])
require.Equal(t, chatB.ID, result[wsB.Workspace.ID])
_, hasC := result[wsC.Workspace.ID]
require.False(t, hasC, "workspace C should not appear in result")
})
t.Run("RejectsTooManyWorkspaceIDs", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
ids := make([]uuid.UUID, 26)
for i := range ids {
ids[i] = uuid.New()
}
_, err := client.GetChatsByWorkspace(ctx, ids)
require.Error(t, err)
requireSDKError(t, err, http.StatusBadRequest)
})
}
func TestSubmitToolResults(t *testing.T) {
t.Parallel()
// setupRequiresAction creates a chat via the DB with dynamic tools,
// inserts an assistant message containing tool-call parts for each
// given toolCallID, and sets the chat status to requires_action.
// It returns the chat row so callers can exercise the endpoint.
//
// Callers must build their coderd with withChatWorkerDisabled: an
// unowned requires_action chat is a worker acquisition candidate,
// and a takeover would synthesize tool cancellations and change the
// chat status underneath the test.
setupRequiresAction := func(
ctx context.Context,
t *testing.T,
db database.Store,
ownerID uuid.UUID,
organizationID uuid.UUID,
modelConfigID uuid.UUID,
dynamicToolName string,
toolCallIDs []string,
) database.Chat {
t.Helper()
// Marshal dynamic tools into the chat row.
dynamicTools := []mcp.Tool{{
Name: dynamicToolName,
Description: "a test dynamic tool",
InputSchema: map[string]any{"type": "object"},
}}
dtJSON, err := json.Marshal(dynamicTools)
require.NoError(t, err)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: organizationID,
OwnerID: ownerID,
LastModelConfigID: modelConfigID,
Title: "tool-results-test",
DynamicTools: pqtype.NullRawMessage{RawMessage: dtJSON, Valid: true},
})
// Build assistant message with tool-call parts.
parts := make([]codersdk.ChatMessagePart, 0, len(toolCallIDs))
for _, id := range toolCallIDs {
parts = append(parts, codersdk.ChatMessagePart{
Type: codersdk.ChatMessagePartTypeToolCall,
ToolCallID: id,
ToolName: dynamicToolName,
Args: json.RawMessage(`{"key":"value"}`),
})
}
content, err := chatprompt.MarshalParts(parts)
require.NoError(t, err)
_ = dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
ModelConfigID: uuid.NullUUID{UUID: modelConfigID, Valid: true},
Role: database.ChatMessageRoleAssistant,
Content: content,
})
// Transition to requires_action.
chat, err = db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusRequiresAction,
})
require.NoError(t, err)
require.Equal(t, database.ChatStatusRequiresAction, chat.Status)
return chat
}
t.Run("Success", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
const toolName = "my_dynamic_tool"
toolCallIDs := []string{"call_abc", "call_def"}
chat := setupRequiresAction(ctx, t, db, user.UserID, user.OrganizationID, modelConfig.ID, toolName, toolCallIDs)
err := client.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{
{ToolCallID: "call_abc", Output: json.RawMessage(`"result_a"`)},
{ToolCallID: "call_def", Output: json.RawMessage(`"result_b"`)},
},
})
require.NoError(t, err)
// Verify status is no longer requires_action. The worker is
// disabled, so the transition comes from SubmitToolResults
// itself.
gotChat, err := client.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.NotEqual(t, codersdk.ChatStatusRequiresAction, gotChat.Status,
"chat should no longer be in requires_action after submitting tool results")
// Verify tool-result messages were persisted.
msgsResp, err := client.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var toolResultCount int
for _, msg := range msgsResp.Messages {
if msg.Role == codersdk.ChatMessageRoleTool {
toolResultCount++
}
}
require.Equal(t, len(toolCallIDs), toolResultCount,
"expected one tool-result message per submitted result")
})
t.Run("WrongStatus", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// Create a chat that is NOT in requires_action status.
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "wrong-status-test",
})
err := client.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{
{ToolCallID: "call_xyz", Output: json.RawMessage(`"nope"`)},
},
})
requireSDKError(t, err, http.StatusConflict)
})
t.Run("MissingResult", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
const toolName = "my_dynamic_tool"
toolCallIDs := []string{"call_one", "call_two"}
chat := setupRequiresAction(ctx, t, db, user.UserID, user.OrganizationID, modelConfig.ID, toolName, toolCallIDs)
// Submit only one of the two required results.
err := client.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{
{ToolCallID: "call_one", Output: json.RawMessage(`"partial"`)},
},
})
requireSDKError(t, err, http.StatusBadRequest)
})
t.Run("UnexpectedResult", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
const toolName = "my_dynamic_tool"
toolCallIDs := []string{"call_real"}
chat := setupRequiresAction(ctx, t, db, user.UserID, user.OrganizationID, modelConfig.ID, toolName, toolCallIDs)
// Submit a result with a wrong tool_call_id.
err := client.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{
{ToolCallID: "call_bogus", Output: json.RawMessage(`"wrong"`)},
},
})
requireSDKError(t, err, http.StatusBadRequest)
})
t.Run("InvalidJSONOutput", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
const toolName = "my_dynamic_tool"
toolCallIDs := []string{"call_json"}
chat := setupRequiresAction(ctx, t, db, user.UserID, user.OrganizationID, modelConfig.ID, toolName, toolCallIDs)
// We must bypass the SDK client because json.RawMessage
// rejects invalid JSON during json.Marshal. A raw HTTP
// request lets the invalid payload reach the server so we
// can verify server-side validation.
rawBody := `{"results":[{"tool_call_id":"call_json","output":not-json,"is_error":false}]}`
url := client.URL.JoinPath(fmt.Sprintf("/api/v2/chats/%s/tool-results", chat.ID)).String()
req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBufferString(rawBody))
require.NoError(t, err)
req.Header.Set("Content-Type", "application/json")
req.Header.Set(codersdk.SessionTokenHeader, client.SessionToken())
resp, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer resp.Body.Close()
require.Equal(t, http.StatusBadRequest, resp.StatusCode)
})
t.Run("DuplicateToolCallID", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
const toolName = "my_dynamic_tool"
toolCallIDs := []string{"call_dup1", "call_dup2"}
chat := setupRequiresAction(ctx, t, db, user.UserID, user.OrganizationID, modelConfig.ID, toolName, toolCallIDs)
err := client.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{
{ToolCallID: "call_dup1", Output: json.RawMessage(`"result_a"`)},
{ToolCallID: "call_dup1", Output: json.RawMessage(`"result_b"`)},
},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "Duplicate tool_call_id")
})
t.Run("EmptyResults", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
const toolName = "my_dynamic_tool"
toolCallIDs := []string{"call_empty"}
chat := setupRequiresAction(ctx, t, db, user.UserID, user.OrganizationID, modelConfig.ID, toolName, toolCallIDs)
err := client.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{},
})
requireSDKError(t, err, http.StatusBadRequest)
})
t.Run("NotFoundForDifferentUser", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
const toolName = "my_dynamic_tool"
toolCallIDs := []string{"call_other"}
chat := setupRequiresAction(ctx, t, db, user.UserID, user.OrganizationID, modelConfig.ID, toolName, toolCallIDs)
// Create a second user and try to submit tool results
// to user A's chat.
otherClientRaw, _ := coderdtest.CreateAnotherUser(
t, client.Client, user.OrganizationID,
)
otherClient := codersdk.NewExperimentalClient(otherClientRaw)
err := otherClient.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{
{ToolCallID: "call_other", Output: json.RawMessage(`"nope"`)},
},
})
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("MemberCanSubmitToolResults", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
memberClientRaw, member := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
memberClient := codersdk.NewExperimentalClient(memberClientRaw)
const toolName = "my_dynamic_tool"
toolCallIDs := []string{"call_member"}
chat := setupRequiresAction(ctx, t, db, member.ID, firstUser.OrganizationID, modelConfig.ID, toolName, toolCallIDs)
err := memberClient.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{
{ToolCallID: "call_member", Output: json.RawMessage(`"result"`)},
},
})
require.NoError(t, err)
})
t.Run("ArchivedChat", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
const toolName = "my_dynamic_tool"
toolCallIDs := []string{"call_archived"}
chat := setupRequiresAction(ctx, t, db, user.UserID, user.OrganizationID, modelConfig.ID, toolName, toolCallIDs)
// Archive the chat.
_, err := db.ArchiveChatByID(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
err = client.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{
{ToolCallID: "call_archived", Output: json.RawMessage(`"should fail"`)},
},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Contains(t, sdkErr.Message, "archived")
})
}
// chatLimitCase runs a test against one deployment configuration of a chat
// limit.
type chatLimitCase struct {
name string
configure func(*coderdtest.Options)
limit int
}
// chatLimitCases returns a Default row that leaves the deployment option
// unset, so the codersdk default applies, plus rows configured below and
// above the default.
func chatLimitCases(option func(*codersdk.ChatConfig) *serpent.Int64, defaultLimit, lower, higher int) []chatLimitCase {
configured := func(name string, limit int) chatLimitCase {
return chatLimitCase{
name: name,
configure: func(o *coderdtest.Options) {
*option(&o.DeploymentValues.AI.Chat) = serpent.Int64(limit)
},
limit: limit,
}
}
return []chatLimitCase{
{name: "Default", configure: func(*coderdtest.Options) {}, limit: defaultLimit},
configured("Lower", lower),
configured("Higher", higher),
}
}
// uploadChatPNGs uploads n small PNG files in order, so each is newer than
// the one before it.
func uploadChatPNGs(ctx context.Context, t *testing.T, client *codersdk.ExperimentalClient, orgID uuid.UUID, prefix string, n int) []uuid.UUID {
t.Helper()
pngData := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}, make([]byte, 64)...)
ids := make([]uuid.UUID, 0, n)
for i := range n {
resp, err := client.UploadChatFile(ctx, orgID, "image/png", fmt.Sprintf("%s-%d.png", prefix, i), bytes.NewReader(pngData))
require.NoError(t, err)
ids = append(ids, resp.ID)
}
return ids
}
func linkedChatFileIDs(ctx context.Context, t *testing.T, client *codersdk.ExperimentalClient, chatID uuid.UUID) []uuid.UUID {
t.Helper()
chat, err := client.GetChat(ctx, chatID)
require.NoError(t, err)
ids := make([]uuid.UUID, 0, len(chat.Files))
for _, f := range chat.Files {
ids = append(ids, f.ID)
}
return ids
}
func TestChatLimitsFromDeploymentConfig(t *testing.T) {
t.Parallel()
t.Run("MaxPromptBytes", func(t *testing.T) {
t.Parallel()
type promptEndpoint struct {
name string
message string
put func(ctx context.Context, client *codersdk.ExperimentalClient, prompt string) error
get func(ctx context.Context, client *codersdk.ExperimentalClient) (string, error)
}
endpoints := []promptEndpoint{
{
name: "SystemPrompt",
message: "System prompt exceeds maximum length.",
put: func(ctx context.Context, client *codersdk.ExperimentalClient, prompt string) error {
return client.UpdateChatSystemPrompt(ctx, codersdk.UpdateChatSystemPromptRequest{
SystemPrompt: prompt,
IncludeDefaultSystemPrompt: ptr.Ref(true),
})
},
get: func(ctx context.Context, client *codersdk.ExperimentalClient) (string, error) {
resp, err := client.GetChatSystemPrompt(ctx)
return resp.SystemPrompt, err
},
},
{
name: "OrganizationSystemPrompt",
message: "System prompt exceeds maximum length.",
put: func(ctx context.Context, client *codersdk.ExperimentalClient, prompt string) error {
org, err := client.OrganizationByName(ctx, codersdk.DefaultOrganization)
if err != nil {
return err
}
return client.UpdateOrganizationChatSystemPrompt(ctx, org.ID, codersdk.UpdateOrganizationChatSystemPromptRequest{
SystemPrompt: prompt,
})
},
get: func(ctx context.Context, client *codersdk.ExperimentalClient) (string, error) {
org, err := client.OrganizationByName(ctx, codersdk.DefaultOrganization)
if err != nil {
return "", err
}
resp, err := client.OrganizationChatSystemPrompt(ctx, org.ID)
return resp.SystemPrompt, err
},
},
{
name: "PlanModeInstructions",
message: "Plan mode instructions exceed maximum length.",
put: func(ctx context.Context, client *codersdk.ExperimentalClient, prompt string) error {
return client.UpdateChatPlanModeInstructions(ctx, codersdk.UpdateChatPlanModeInstructionsRequest{
PlanModeInstructions: prompt,
})
},
get: func(ctx context.Context, client *codersdk.ExperimentalClient) (string, error) {
resp, err := client.GetChatPlanModeInstructions(ctx)
return resp.PlanModeInstructions, err
},
},
{
name: "UserCustomPrompt",
message: "Custom prompt exceeds maximum length.",
put: func(ctx context.Context, client *codersdk.ExperimentalClient, prompt string) error {
_, err := client.UpdateUserChatCustomPrompt(ctx, codersdk.UserChatCustomPrompt{CustomPrompt: prompt})
return err
},
get: func(ctx context.Context, client *codersdk.ExperimentalClient) (string, error) {
resp, err := client.GetUserChatCustomPrompt(ctx)
return resp.CustomPrompt, err
},
},
}
// Lower sits below the JSON envelope size, so rejection must come from
// the prompt check rather than the body cap. Higher lifts the body cap
// above its 256 KiB floor.
limitCases := chatLimitCases(func(c *codersdk.ChatConfig) *serpent.Int64 { return &c.MaxPromptBytes },
codersdk.DefaultChatMaxPromptBytes, 16, 512*1024)
for _, lc := range limitCases {
t.Run(lc.name, func(t *testing.T) {
t.Parallel()
client := newChatClient(t, lc.configure)
_ = coderdtest.CreateFirstUser(t, client.Client)
for _, ep := range endpoints {
t.Run(ep.name, func(t *testing.T) {
t.Parallel()
requireStored := func(ctx context.Context, t *testing.T, want string) {
t.Helper()
got, err := ep.get(ctx, client)
require.NoError(t, err)
require.Equal(t, want, got)
}
requireAccepted := func(ctx context.Context, t *testing.T, prompt string) {
t.Helper()
require.NoError(t, ep.put(ctx, client, prompt))
requireStored(ctx, t, prompt)
}
requireRejected := func(ctx context.Context, t *testing.T, prompt, stored string) {
t.Helper()
sdkErr := requireSDKError(t, ep.put(ctx, client, prompt), http.StatusBadRequest)
require.Equal(t, ep.message, sdkErr.Message)
require.Equal(t, fmt.Sprintf("Maximum length is %d bytes, got %d.", lc.limit, len(prompt)), sdkErr.Detail)
requireStored(ctx, t, stored)
}
ctx := testutil.Context(t, testutil.WaitLong)
atLimit := strings.Repeat("a", lc.limit)
requireAccepted(ctx, t, atLimit)
requireRejected(ctx, t, atLimit+"a", atLimit)
// "é" is two bytes, so the limit counts bytes, not characters.
multibyte := strings.Repeat("é", lc.limit/2)
requireAccepted(ctx, t, multibyte)
requireRejected(ctx, t, multibyte+"é", multibyte)
})
}
})
}
})
t.Run("MaxPromptBytesDoesNotBoundChatCreation", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
values := coderdtest.DeploymentValues(t)
values.AI.Chat.MaxPromptBytes = serpent.Int64(16)
client := newChatClientWithDeploymentValues(t, values)
user := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
_, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: strings.Repeat("a", 1024),
}},
UnsafeDynamicTools: []codersdk.DynamicTool{{
Name: "lookup",
Description: strings.Repeat("d", 1024),
}},
})
require.NoError(t, err)
})
t.Run("MaxQueuedMessagesPerChat", func(t *testing.T) {
t.Parallel()
limitCases := chatLimitCases(func(c *codersdk.ChatConfig) *serpent.Int64 { return &c.MaxQueuedMessagesPerChat },
codersdk.DefaultChatMaxQueuedMessagesPerChat, 2, 25)
for _, lc := range limitCases {
t.Run(lc.name, func(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t, lc.configure, withChatWorkerDisabled)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
ctx := testutil.Context(t, testutil.WaitLong)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "queue cap " + lc.name,
})
// Another worker owns the running chat, so every send queues.
_, err := db.UpdateChatStatus(dbauthz.AsSystemRestricted(ctx), database.UpdateChatStatusParams{
ID: chat.ID,
Status: database.ChatStatusRunning,
WorkerID: uuid.NullUUID{UUID: uuid.New(), Valid: true},
StartedAt: sql.NullTime{Time: time.Now(), Valid: true},
HeartbeatAt: sql.NullTime{Time: time.Now(), Valid: true},
})
require.NoError(t, err)
send := func(ctx context.Context, i int) (codersdk.CreateChatMessageResponse, error) {
return client.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: fmt.Sprintf("queued message %d", i),
}},
BusyBehavior: codersdk.ChatBusyBehaviorQueue,
})
}
for i := range lc.limit {
resp, err := send(ctx, i)
require.NoError(t, err)
require.True(t, resp.Queued, "message %d should queue", i)
}
_, err = send(ctx, lc.limit)
sdkErr := requireSDKError(t, err, http.StatusTooManyRequests)
require.Equal(t, "Message queue is full.", sdkErr.Message)
require.Equal(t, fmt.Sprintf("Maximum %d messages can be queued.", lc.limit), sdkErr.Detail)
queued, err := db.GetChatQueuedMessages(dbauthz.AsSystemRestricted(ctx), chat.ID)
require.NoError(t, err)
require.Len(t, queued, lc.limit)
})
}
})
}
func TestPostChats_DynamicToolValidation(t *testing.T) {
t.Parallel()
t.Run("TooManyTools", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
user := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
tools := make([]codersdk.DynamicTool, 251)
for i := range tools {
tools[i] = codersdk.DynamicTool{
Name: fmt.Sprintf("tool-%d", i),
}
}
_, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
}},
UnsafeDynamicTools: tools,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Too many dynamic tools.", sdkErr.Message)
})
t.Run("EmptyToolName", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
user := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
_, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
}},
UnsafeDynamicTools: []codersdk.DynamicTool{
{Name: ""},
},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Dynamic tool name must not be empty.", sdkErr.Message)
})
t.Run("DuplicateToolName", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client := newChatClient(t)
user := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
_, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
}},
UnsafeDynamicTools: []codersdk.DynamicTool{
{Name: "dup-tool"},
{Name: "dup-tool"},
},
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "Duplicate dynamic tool name.", sdkErr.Message)
})
t.Run("CallerSuppliedToolsDisabled", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
values := coderdtest.DeploymentValues(t)
values.DisableChatCallerSuppliedTools = serpent.Bool(true)
client := newChatClientWithDeploymentValues(t, values)
user := coderdtest.CreateFirstUser(t, client.Client)
_ = createChatModel(t, client)
_, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
}},
UnsafeDynamicTools: []codersdk.DynamicTool{
{Name: "my_dynamic_tool"},
},
})
sdkErr := requireSDKError(t, err, http.StatusForbidden)
require.Equal(t, "Caller-supplied tools are disabled on this deployment.", sdkErr.Message)
chat, err := client.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: user.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "hello",
}},
})
require.NoError(t, err)
require.NotEqual(t, uuid.Nil, chat.ID)
err = client.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{{ToolCallID: "call_abc", Output: json.RawMessage(`"result"`)}},
})
sdkErr = requireSDKError(t, err, http.StatusForbidden)
require.Equal(t, "Caller-supplied tools are disabled on this deployment.", sdkErr.Message)
})
}
// requireActiveVersionStore always returns RequireActiveVersion: true so
// tests can exercise relevant code paths without an enterprise license.
type requireActiveVersionStore struct{}
func (requireActiveVersionStore) GetTemplateAccessControl(_ database.Template) dbauthz.TemplateAccessControl {
return dbauthz.TemplateAccessControl{RequireActiveVersion: true}
}
func (requireActiveVersionStore) SetTemplateAccessControl(_ context.Context, _ database.Store, _ uuid.UUID, _ dbauthz.TemplateAccessControl) error {
return nil
}
func TestChatStartWorkspace_RequireActiveVersion(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{})
var store dbauthz.AccessControlStore = requireActiveVersionStore{}
api.AccessControlStore.Store(&store)
db := api.Database
user := coderdtest.CreateFirstUser(t, rawClient)
// Given: active template version v1 plus workspace stopped on v1.
wsResp := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OwnerID: user.UserID,
OrganizationID: user.OrganizationID,
}).Seed(database.WorkspaceBuild{
Transition: database.WorkspaceTransitionStop,
}).Do()
tmplID := wsResp.Workspace.TemplateID
v1ID := wsResp.Build.TemplateVersionID
// Given: a new active version v2 is published.
v2Resp := dbfake.TemplateVersion(t, db).Seed(database.TemplateVersion{
TemplateID: uuid.NullUUID{UUID: tmplID, Valid: true},
OrganizationID: user.OrganizationID,
CreatedBy: user.UserID,
}).Do()
v2 := v2Resp.TemplateVersion
require.NotEqual(t, v1ID, v2.ID, "v2 must differ from v1")
// When: we start the workspace through chatStartWorkspace.
build, err := coderd.ChatStartWorkspace(api, ctx, user.UserID, wsResp.Workspace.ID,
codersdk.CreateWorkspaceBuildRequest{
Transition: codersdk.WorkspaceTransitionStart,
})
// Then: the build is auto-updated to the active version.
require.NoError(t, err)
require.Equal(t, v2.ID, build.TemplateVersionID, "build must be on the active version")
require.Nil(t, build.TemplateVersionPresetID, "no preset must be applied")
}
func TestChatStopWorkspace_BypassesRequireActiveVersion(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
rawClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{})
var store dbauthz.AccessControlStore = requireActiveVersionStore{}
api.AccessControlStore.Store(&store)
db := api.Database
user := coderdtest.CreateFirstUser(t, rawClient)
wsResp := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
OwnerID: user.UserID,
OrganizationID: user.OrganizationID,
}).Seed(database.WorkspaceBuild{
Transition: database.WorkspaceTransitionStart,
}).Do()
v1ID := wsResp.Build.TemplateVersionID
tmplID := wsResp.Workspace.TemplateID
v2Resp := dbfake.TemplateVersion(t, db).Seed(database.TemplateVersion{
TemplateID: uuid.NullUUID{UUID: tmplID, Valid: true},
OrganizationID: user.OrganizationID,
CreatedBy: user.UserID,
}).Do()
v2 := v2Resp.TemplateVersion
require.NotEqual(t, v1ID, v2.ID, "v2 must differ from v1")
build, err := coderd.ChatStopWorkspace(api, ctx, user.UserID, wsResp.Workspace.ID,
codersdk.CreateWorkspaceBuildRequest{})
require.NoError(t, err)
require.Equal(t, codersdk.WorkspaceTransitionStop, build.Transition)
require.Equal(t, v1ID, build.TemplateVersionID,
"stop must not apply RequireActiveVersion start-only logic")
require.NotEqual(t, v2.ID, build.TemplateVersionID)
}
func TestGetChatMessages_Pagination(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
// seedChat creates a chat and inserts `count` user messages, returning
// the chat and the inserted message IDs in the order they were
// persisted (ascending). Callers use these IDs as cursor values.
seedChat := func(t *testing.T, count int) (database.Chat, []int64) {
t.Helper()
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "pagination-test",
})
ids := make([]int64, count)
for i := range count {
content, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
codersdk.ChatMessageText(fmt.Sprintf("msg %d", i)),
})
require.NoError(t, err)
message := dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
CreatedBy: uuid.NullUUID{UUID: user.UserID, Valid: true},
ModelConfigID: uuid.NullUUID{UUID: modelConfig.ID, Valid: true},
Role: database.ChatMessageRoleUser,
Content: content,
})
ids[i] = message.ID
}
return chat, ids
}
// Seed the queue so an empty QueuedMessages result tests cursor suppression.
for _, tc := range []struct {
name string
opts func(ids []int64) *codersdk.ChatMessagesPaginationOptions
want []int
hasMore bool
wantQueued int
}{
{
name: "NoCursorReturnsAllDESCPlusQueued",
want: []int{4, 3, 2, 1, 0},
wantQueued: 1,
},
{
name: "BeforeIDReturnsOlderAndSuppressesQueued",
opts: func(ids []int64) *codersdk.ChatMessagesPaginationOptions {
return &codersdk.ChatMessagesPaginationOptions{BeforeID: ids[2]}
},
want: []int{1, 0},
},
{
// ASC order so a polling caller can advance its cursor to
// max(returned_ids) without gaps.
name: "AfterIDReturnsNewerInASCOrderForMonotonicPolling",
opts: func(ids []int64) *codersdk.ChatMessagesPaginationOptions {
return &codersdk.ChatMessagesPaginationOptions{AfterID: ids[1]}
},
want: []int{2, 3, 4},
},
{
name: "AfterAndBeforeIDReturnsOpenRange",
opts: func(ids []int64) *codersdk.ChatMessagesPaginationOptions {
return &codersdk.ChatMessagesPaginationOptions{AfterID: ids[0], BeforeID: ids[4]}
},
want: []int{3, 2, 1},
},
{
// The ASC polling path returns the OLDEST unseen messages
// first. A burst larger than `limit` would otherwise silently
// drop the oldest rows between polls on the DESC path.
name: "LimitCapsAfterIDPageToOldestAndSetsHasMore",
opts: func(ids []int64) *codersdk.ChatMessagesPaginationOptions {
return &codersdk.ChatMessagesPaginationOptions{AfterID: ids[0], Limit: 2}
},
want: []int{1, 2},
hasMore: true,
},
{
// The steady-state polling case: the caller already has every
// message, so after_id equals the largest seen id. The server
// must return an empty page, not the last row again.
name: "AfterIDAtOrAboveMaxReturnsEmpty",
opts: func(ids []int64) *codersdk.ChatMessagesPaginationOptions {
return &codersdk.ChatMessagesPaginationOptions{AfterID: ids[4]}
},
want: []int{},
},
} {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
chat, ids := seedChat(t, 5)
content, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("queued"),
})
require.NoError(t, err)
_ = insertTestChatQueuedMessage(ctx, t, db, chat.ID, content, modelConfig.ID)
var opts *codersdk.ChatMessagesPaginationOptions
if tc.opts != nil {
opts = tc.opts(ids)
}
resp, err := client.GetChatMessages(ctx, chat.ID, opts)
require.NoError(t, err)
require.Equal(t, tc.hasMore, resp.HasMore)
require.Len(t, resp.QueuedMessages, tc.wantQueued)
// A cursored page can leave out newer messages.
require.Equal(t, tc.opts == nil, resp.SnapshotVersion != 0, "only the page without a cursor includes snapshot_version")
want := make([]int64, len(tc.want))
for i, pos := range tc.want {
want[i] = ids[pos]
}
got := make([]int64, len(resp.Messages))
for i, m := range resp.Messages {
got[i] = m.ID
}
require.Equal(t, want, got)
})
}
for _, tc := range []struct {
name string
afterID string
}{
{"NegativeAfterIDReturns400", "-1"},
{"NonNumericAfterIDReturns400", "abc"},
} {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
chat, _ := seedChat(t, 1)
res, err := client.Request(
ctx,
http.MethodGet,
fmt.Sprintf("/api/v2/chats/%s/messages?after_id=%s", chat.ID, tc.afterID),
nil,
)
require.NoError(t, err)
defer res.Body.Close()
sdkErr := requireSDKError(t, codersdk.ReadBodyAsError(res), http.StatusBadRequest)
require.Equal(t, "Query parameters have invalid values.", sdkErr.Message)
require.True(t,
slices.ContainsFunc(sdkErr.Validations, func(v codersdk.ValidationError) bool {
return v.Field == "after_id"
}),
"expected validation error for after_id field",
)
})
}
t.Run("AfterIDGreaterThanOrEqualBeforeIDReturns400", func(t *testing.T) {
t.Parallel()
chat, ids := seedChat(t, 3)
// Transposed cursors: after >= before. Fail loudly rather
// than return an empty page indistinguishable from
// "no messages in this range."
for _, tc := range []struct {
name string
after int64
before int64
}{
{"Transposed", ids[2], ids[0]},
{"Equal", ids[1], ids[1]},
} {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
_, err := client.GetChatMessages(ctx, chat.ID, &codersdk.ChatMessagesPaginationOptions{
AfterID: tc.after,
BeforeID: tc.before,
})
sdkErr := requireSDKError(t, err, http.StatusBadRequest)
require.Equal(t, "after_id must be less than before_id.", sdkErr.Message)
})
}
})
t.Run("AfterIDPollingWalksBurstWithoutGaps", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
// Simulate a polling client that has already acknowledged the
// first message (cursor = ids[0]) when a burst of
// `burstSize` new messages arrives. With `limit=pageSize` and
// `burstSize > pageSize`, the naive DESC-ordered path would
// silently drop the oldest rows between polls. The ASC
// dispatch lets the client walk the whole burst by advancing
// after_id to max(returned_ids) on each tick.
const burstSize = 60
const pageSize = 25
// Seed burstSize+1 rows; ids[0] is the "already acknowledged"
// message the client saw before the burst.
chat, ids := seedChat(t, burstSize+1)
var seen []int64
cursor := ids[0]
maxPages := (burstSize / pageSize) + 2
for range maxPages {
resp, err := client.GetChatMessages(ctx, chat.ID, &codersdk.ChatMessagesPaginationOptions{
AfterID: cursor,
Limit: pageSize,
})
require.NoError(t, err)
if len(resp.Messages) == 0 {
require.False(t, resp.HasMore)
break
}
for _, m := range resp.Messages {
seen = append(seen, m.ID)
}
// Advance to max(returned). On the ASC path this is the
// last element of the returned slice.
cursor = resp.Messages[len(resp.Messages)-1].ID
if !resp.HasMore {
break
}
}
require.Equal(t, ids[1:], seen,
"polling walk must return every burst row exactly once in ascending order")
})
}
func TestGetChatMessages_TurnStartID(t *testing.T) {
t.Parallel()
client, db := newChatClientWithDatabase(t)
user := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: user.OrganizationID,
OwnerID: user.UserID,
LastModelConfigID: modelConfig.ID,
Title: "turn-start-test",
})
insert := func(role database.ChatMessageRole, visibility database.ChatMessageVisibility) int64 {
content, err := chatprompt.MarshalParts([]codersdk.ChatMessagePart{
codersdk.ChatMessageText(string(role)),
})
require.NoError(t, err)
return dbgen.ChatMessage(t, db, database.ChatMessage{
ChatID: chat.ID,
CreatedBy: uuid.NullUUID{UUID: user.UserID, Valid: true},
ModelConfigID: uuid.NullUUID{UUID: modelConfig.ID, Valid: true},
Role: role,
Visibility: visibility,
Content: content,
}).ID
}
const (
roleUser = database.ChatMessageRoleUser
roleAssistant = database.ChatMessageRoleAssistant
both = database.ChatMessageVisibilityBoth
modelOnly = database.ChatMessageVisibilityModel
)
preamble := insert(roleAssistant, both)
firstPrompt := insert(roleUser, both)
firstStep := insert(roleAssistant, both)
_ = insert(roleUser, modelOnly)
afterModelOnly := insert(roleAssistant, both)
deletedPrompt := insert(roleUser, both)
ctx := testutil.Context(t, testutil.WaitLong)
require.NoError(t, db.SoftDeleteChatMessagesAfterID(dbauthz.AsSystemRestricted(ctx), database.SoftDeleteChatMessagesAfterIDParams{
ChatID: chat.ID,
AfterID: deletedPrompt - 1,
}))
afterDeletedPrompt := insert(roleAssistant, both)
lastPrompt := insert(roleUser, both)
lastStep := insert(roleAssistant, both)
tests := []struct {
name string
opts codersdk.ChatMessagesPaginationOptions
// oldest is the expected last ID of a newest-first page; zero
// means the page is empty.
oldest int64
want *int64
}{
{"MidTurn", codersdk.ChatMessagesPaginationOptions{Limit: 1}, lastStep, &lastPrompt},
{"PageSpanningTurnsSkipsDeletedPrompt", codersdk.ChatMessagesPaginationOptions{BeforeID: lastStep, Limit: 2}, afterDeletedPrompt, &firstPrompt},
{"SkipsModelOnlyUserRow", codersdk.ChatMessagesPaginationOptions{BeforeID: deletedPrompt, Limit: 1}, afterModelOnly, &firstPrompt},
{"OldestIsPrompt", codersdk.ChatMessagesPaginationOptions{BeforeID: firstStep, Limit: 1}, firstPrompt, &firstPrompt},
{"NoPromptBeforeOldest", codersdk.ChatMessagesPaginationOptions{BeforeID: firstPrompt}, preamble, nil},
{"EmptyPage", codersdk.ChatMessagesPaginationOptions{BeforeID: preamble}, 0, nil},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
resp, err := client.GetChatMessages(ctx, chat.ID, &tt.opts)
require.NoError(t, err)
if tt.oldest == 0 {
require.Empty(t, resp.Messages)
} else {
require.NotEmpty(t, resp.Messages)
require.Equal(t, tt.oldest, resp.Messages[len(resp.Messages)-1].ID)
}
require.Equal(t, tt.want, resp.TurnStartID)
})
}
t.Run("AfterIDPollingOmitsTurnStart", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
resp, err := client.GetChatMessages(ctx, chat.ID, &codersdk.ChatMessagesPaginationOptions{AfterID: firstStep})
require.NoError(t, err)
require.NotEmpty(t, resp.Messages)
require.Nil(t, resp.TurnStartID)
})
}
func requireSDKError(t *testing.T, err error, expectedStatus int) *codersdk.Error {
t.Helper()
var sdkErr *codersdk.Error
require.ErrorAs(t, err, &sdkErr)
require.Equal(t, expectedStatus, sdkErr.StatusCode())
return sdkErr
}
func TestChatReadOnlySharedWriteHandlers(t *testing.T) {
t.Parallel()
const sharedChatText = "read only shared chat"
setup := func(t *testing.T) (
ctx context.Context,
ownerClient *codersdk.ExperimentalClient,
sharedClient *codersdk.ExperimentalClient,
chat codersdk.Chat,
db database.Store,
) {
t.Helper()
ctx = testutil.Context(t, testutil.WaitLong)
ownerClient, db = newChatClientWithDatabase(t)
owner := coderdtest.CreateFirstUser(t, ownerClient.Client)
_ = createChatModel(t, ownerClient)
sharedRaw, sharedUser := coderdtest.CreateAnotherUser(
t,
ownerClient.Client,
owner.OrganizationID,
)
sharedClient = codersdk.NewExperimentalClient(sharedRaw)
var err error
chat, err = ownerClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: owner.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: sharedChatText,
}},
})
require.NoError(t, err)
err = db.UpdateChatACLByID(dbauthz.As(ctx, rbac.Subject{
ID: owner.UserID.String(),
Roles: rbac.RoleIdentifiers{rbac.RoleOwner()},
Scope: rbac.ScopeAll,
}), database.UpdateChatACLByIDParams{
ID: chat.ID,
UserACL: database.ChatACL{
sharedUser.ID.String(): database.ChatACLEntry{Permissions: []policy.Action{policy.ActionRead}},
},
GroupACL: database.ChatACL{},
})
require.NoError(t, err)
return ctx, ownerClient, sharedClient, chat, db
}
t.Run("GetChatAndMessages", func(t *testing.T) {
t.Parallel()
ctx, _, sharedClient, chat, _ := setup(t)
gotChat, err := sharedClient.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, chat.ID, gotChat.ID)
messagesResult, err := sharedClient.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
require.NotEmpty(t, messagesResult.Messages)
foundUserMessage := false
for _, message := range messagesResult.Messages {
if message.Role != codersdk.ChatMessageRoleUser {
continue
}
for _, part := range message.Content {
if part.Type == codersdk.ChatMessagePartTypeText && part.Text == sharedChatText {
foundUserMessage = true
break
}
}
}
require.True(t, foundUserMessage)
})
t.Run("PatchChat", func(t *testing.T) {
t.Parallel()
ctx, _, sharedClient, chat, _ := setup(t)
err := sharedClient.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Archived: ptr.Ref(true),
})
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("PatchChatMessage", func(t *testing.T) {
t.Parallel()
ctx, ownerClient, sharedClient, chat, _ := setup(t)
messagesResult, err := ownerClient.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var userMessageID int64
for _, msg := range messagesResult.Messages {
if msg.Role == codersdk.ChatMessageRoleUser {
userMessageID = msg.ID
break
}
}
require.NotZero(t, userMessageID)
_, err = sharedClient.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "read only user cannot edit",
}},
})
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("PostChatMessages", func(t *testing.T) {
t.Parallel()
ctx, _, sharedClient, chat, _ := setup(t)
_, err := sharedClient.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "read only user cannot send messages",
}},
})
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("PromoteChatQueuedMessage", func(t *testing.T) {
t.Parallel()
ctx, _, sharedClient, chat, db := setup(t)
queuedContent, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("queued"),
})
require.NoError(t, err)
queuedMessage := insertTestChatQueuedMessage(ctx, t, db, chat.ID, queuedContent, chat.LastModelConfigID)
res, err := sharedClient.Request(
ctx,
http.MethodPost,
fmt.Sprintf("/api/v2/chats/%s/queue/%d/promote", chat.ID, queuedMessage.ID),
nil,
)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
t.Run("PostChatToolResults", func(t *testing.T) {
t.Parallel()
ctx, _, sharedClient, chat, _ := setup(t)
err := sharedClient.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{{
ToolCallID: "call_read_only",
Output: json.RawMessage(`"forbidden"`),
}},
})
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("DeleteChatQueuedMessage", func(t *testing.T) {
t.Parallel()
ctx, _, sharedClient, chat, db := setup(t)
queuedContent, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("queued"),
})
require.NoError(t, err)
queuedMessage := insertTestChatQueuedMessage(ctx, t, db, chat.ID, queuedContent, chat.LastModelConfigID)
res, err := sharedClient.Request(
ctx,
http.MethodDelete,
fmt.Sprintf("/api/v2/chats/%s/queue/%d", chat.ID, queuedMessage.ID),
nil,
)
require.NoError(t, err)
defer res.Body.Close()
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
t.Run("InterruptChat", func(t *testing.T) {
t.Parallel()
ctx, _, sharedClient, chat, _ := setup(t)
_, err := sharedClient.InterruptChat(ctx, chat.ID)
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("ReconcileInvalidChatState", func(t *testing.T) {
t.Parallel()
ctx, _, sharedClient, chat, _ := setup(t)
_, err := sharedClient.ReconcileInvalidChatState(ctx, chat.ID)
requireSDKError(t, err, http.StatusNotFound)
})
t.Run("ProposeChatTitle", func(t *testing.T) {
t.Parallel()
ctx, _, sharedClient, chat, _ := setup(t)
_, err := sharedClient.ProposeChatTitle(ctx, chat.ID)
requireSDKError(t, err, http.StatusNotFound)
})
}
// TestChatOwnerOnlyWriteHandlers verifies that only the chat owner can
// call handlers that trigger chat processing. Org admins pass the RBAC
// ActionUpdate check (org-level permission) but must still be blocked
// because processing forwards the *owner's* credentials to external
// services.
func TestChatOwnerOnlyWriteHandlers(t *testing.T) {
t.Parallel()
// setupOrgAdminAndOwnerChat creates an org-admin user and a chat
// owned by the first (site-admin) user. Returns both clients,
// the chat, and the DB handle.
setupOrgAdminAndOwnerChat := func(t *testing.T) (
ownerClient *codersdk.ExperimentalClient,
adminClient *codersdk.ExperimentalClient,
chat codersdk.Chat,
db database.Store,
) {
t.Helper()
ctx := testutil.Context(t, testutil.WaitLong)
ownerClient, db = newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, ownerClient.Client)
_ = createChatModel(t, ownerClient)
// Create a chat owned by the first user.
var err error
chat, err = ownerClient.CreateChat(ctx, codersdk.CreateChatRequest{
OrganizationID: firstUser.OrganizationID,
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "owner chat for authz test",
}},
})
require.NoError(t, err)
// Create an org admin in the same org.
orgAdminRaw, _ := coderdtest.CreateAnotherUser(
t,
ownerClient.Client,
firstUser.OrganizationID,
rbac.ScopedRoleOrgAdmin(firstUser.OrganizationID),
)
adminClient = codersdk.NewExperimentalClient(orgAdminRaw)
return ownerClient, adminClient, chat, db
}
t.Run("PostChatMessages", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, adminClient, chat, _ := setupOrgAdminAndOwnerChat(t)
_, err := adminClient.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "org admin should not be able to send this",
}},
})
sdkErr := requireSDKError(t, err, http.StatusForbidden)
require.Contains(t, sdkErr.Message, "Only the chat owner")
})
t.Run("CompactChat", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, adminClient, chat, _ := setupOrgAdminAndOwnerChat(t)
_, err := adminClient.CompactChat(ctx, chat.ID)
sdkErr := requireSDKError(t, err, http.StatusForbidden)
require.Contains(t, sdkErr.Message, "Only the chat owner")
})
t.Run("PatchChatMessage", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
ownerClient, adminClient, chat, _ := setupOrgAdminAndOwnerChat(t)
// Fetch the first user message to get a valid message ID.
messagesResult, err := ownerClient.GetChatMessages(ctx, chat.ID, nil)
require.NoError(t, err)
var userMessageID int64
for _, msg := range messagesResult.Messages {
if msg.Role == codersdk.ChatMessageRoleUser {
userMessageID = msg.ID
break
}
}
require.NotZero(t, userMessageID)
_, err = adminClient.EditChatMessage(ctx, chat.ID, userMessageID, codersdk.EditChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "org admin should not be able to edit this",
}},
})
sdkErr := requireSDKError(t, err, http.StatusForbidden)
require.Contains(t, sdkErr.Message, "Only the chat owner")
})
t.Run("PromoteChatQueuedMessage", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, adminClient, chat, db := setupOrgAdminAndOwnerChat(t)
// Insert a queued message directly in the DB.
queuedContent, err := json.Marshal([]codersdk.ChatMessagePart{
codersdk.ChatMessageText("queued"),
})
require.NoError(t, err)
queuedMessage := insertTestChatQueuedMessage(ctx, t, db, chat.ID, queuedContent, chat.LastModelConfigID)
// Org admin tries to promote.
promoteRes, err := adminClient.Request(
ctx,
http.MethodPost,
fmt.Sprintf("/api/v2/chats/%s/queue/%d/promote", chat.ID, queuedMessage.ID),
nil,
)
require.NoError(t, err)
defer promoteRes.Body.Close()
require.Equal(t, http.StatusForbidden, promoteRes.StatusCode)
})
t.Run("SubmitToolResults", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, adminClient, chat, _ := setupOrgAdminAndOwnerChat(t)
err := adminClient.SubmitToolResults(ctx, chat.ID, codersdk.SubmitToolResultsRequest{
Results: []codersdk.ToolResult{{
ToolCallID: "call_forbidden",
Output: json.RawMessage(`"forbidden"`),
}},
})
sdkErr := requireSDKError(t, err, http.StatusForbidden)
require.Contains(t, sdkErr.Message, "Only the chat owner")
})
t.Run("ProposeChatTitle", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
_, adminClient, chat, _ := setupOrgAdminAndOwnerChat(t)
_, err := adminClient.ProposeChatTitle(ctx, chat.ID)
sdkErr := requireSDKError(t, err, http.StatusForbidden)
require.Contains(t, sdkErr.Message, "Only the chat owner")
})
// Verify the owner can still operate normally.
t.Run("OwnerCanSendMessages", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
ownerClient, _, chat, _ := setupOrgAdminAndOwnerChat(t)
_, err := ownerClient.CreateChatMessage(ctx, chat.ID, codersdk.CreateChatMessageRequest{
Content: []codersdk.ChatInputPart{{
Type: codersdk.ChatInputPartTypeText,
Text: "owner should succeed",
}},
})
// The message is accepted (no 403). It may fail downstream
// (e.g. no running LLM) but that is not a 403.
if err != nil {
var sdkErr *codersdk.Error
if xerrors.As(err, &sdkErr) {
require.NotEqual(t, http.StatusForbidden, sdkErr.StatusCode(),
"owner must not receive 403")
}
}
})
}
func TestChatReadState(t *testing.T) {
t.Parallel()
hasUnread := func(ctx context.Context, t *testing.T, client *codersdk.ExperimentalClient, chatID uuid.UUID) bool {
t.Helper()
chats, err := client.ListChats(ctx, nil)
require.NoError(t, err)
for _, chat := range chats {
if chat.ID == chatID {
return chat.HasUnread
}
}
require.FailNow(t, "chat not found in list")
return false
}
t.Run("MarkReadAndUnread", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: firstUser.UserID,
LastModelConfigID: modelConfig.ID,
Title: "read state chat",
})
insertAssistantMessage(t, db, chat.ID, modelConfig.ID)
// A chat the owner has never opened starts unread.
require.True(t, hasUnread(ctx, t, client, chat.ID))
require.NoError(t, client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Read: ptr.Ref(true),
}))
require.False(t, hasUnread(ctx, t, client, chat.ID))
require.NoError(t, client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Read: ptr.Ref(false),
}))
require.True(t, hasUnread(ctx, t, client, chat.ID))
})
t.Run("NonOwnerForbidden", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitLong)
client, db := newChatClientWithDatabase(t)
firstUser := coderdtest.CreateFirstUser(t, client.Client)
modelConfig := createChatModel(t, client)
_, otherUser := coderdtest.CreateAnotherUser(t, client.Client, firstUser.OrganizationID)
chat := dbgen.Chat(t, db, database.Chat{
OrganizationID: firstUser.OrganizationID,
OwnerID: otherUser.ID,
LastModelConfigID: modelConfig.ID,
Title: "other user chat",
})
insertAssistantMessage(t, db, chat.ID, modelConfig.ID)
// The deployment owner may update the chat but must not move
// another user's read cursor, and the rejection must land before
// any other field of the same request is written.
err := client.UpdateChat(ctx, chat.ID, codersdk.UpdateChatRequest{
Title: ptr.Ref("renamed by admin"),
Read: ptr.Ref(true),
})
var sdkErr *codersdk.Error
require.ErrorAs(t, err, &sdkErr)
require.Equal(t, http.StatusForbidden, sdkErr.StatusCode())
persisted, err := client.GetChat(ctx, chat.ID)
require.NoError(t, err)
require.Equal(t, "other user chat", persisted.Title)
})
}