mirror of
https://github.com/coder/coder.git
synced 2026-11-22 03:18:31 +08:00
a3fbd2384d668300a93ead2193232faed11475a8
604
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
a3fbd2384d |
feat: add the Agents automations list page and chat-list automation filter (#30171)
Closes CODAGT-1213. Part of CODAGT-1135 (Automations for Coder Agents,
RFC step 7).
Adds an Automations list to the Agents UI and an `automation_id` filter
on the chat list, so users can see their automations and find the chats
an automation created or wrote to.
## Changes
- **Chat-list filter:** `GET /api/v2/chats?automation_id=<uuid>` returns
root chats whose `chats.automation_id` matches (chats the automation
created) and chats with a non-deleted message whose
`chat_messages.automation_id` matches (chats it wrote to). The nil UUID
is rejected, because the query uses it as "no filter". It is honored
only when the `chat-automations` experiment is on for the caller;
otherwise it is ignored, as the RFC says, and the evaluator runs only
when the parameter is present. Chat authorization is unchanged. Swagger
documents the parameter, and `codersdk.ListChatsOptions` gains
`AutomationID`. The existing partial indexes back the filter.
- **List page:** `/agents/automations`, with an **Automations** sidebar
entry. Both are hidden when the experiment is off for the viewer
(per-user experiment list). The page lists the automations of the
organization selected in the Agents organization picker; it shares the
stored selection with the new-chat form and has its own picker. Columns:
name (with the creating chat for agent-created automations), trigger
(cron and time zone, or webhook single or multi use), target (chat link,
"New chat each run", or a **Missing target** badge for a deleted or
archived target), next run from the server's `next_run_times`, an
enabled switch (PATCH; a non-owner cannot re-enable), **Run now** (owner
only, schedules only, disabled for a missing target and while another
run is pending), and **View chats** (owner only; a paged dialog backed
by the new filter). Chat titles are looked up only for the viewer's own
automations. The list refetches every minute so the next run stays
current. On mobile, the chats header links to the page, which opens full
width with a back link. A Run now failure, such as `409` for a busy chat
with skip or `429` for a full queue or share, shows the server message
in an alert above the table.
- Out of scope, per the ticket: the **Last skipped run** column, and the
editor (CODAGT-1214). The empty state points to the API because the
`manage_automations` tool is not in this stack yet.
## Validation
- Go: `TestListChats/AutomationFilter` covers:
- created and written-to chats, deleted messages, and another user's
chat;
- an unknown id, a malformed id (`400`), and the nil UUID (`400`);
- the experiment turned off by a per-user rule, where the parameter is
ignored, including a malformed id.
- Vitest (`AgentAutomationsPage.test.tsx`), all asserting requests:
- the selected organization's list is requested, and switching the
picker refetches and stores the choice;
- the switch sends `PATCH {enabled:false}`;
- Run now sends its POST when the server answers `409` or `429`;
- View chats requests `?automation_id=`, and Load more requests the next
page;
- nothing is requested with the experiment off.
- Storybook (Pixel): `WithAutomations`, `OtherOwner`, `Empty`,
`MissingTarget`, `RunNowError`, `ChatsDialog`,
`ChatsDialogLoadMoreError`, `Loading`, `RefetchError`, `ListError`, and
`ChatsSidebar/MobileWithAutomations`.
- Remote dogfood UAT: PASS in round 1 (`fa60a15767`) and round 2 on the
current head `b37e9d99d0`. Round 2 repeated every criterion and verified
the review fixes. Screenshots are in the comments below.
- `coder-frontend-review` self-review: every role passes after fixes on
each update, except two items:
- the experiment-off test waits for the not-found page only as a sync
point before asserting that no request was sent;
- there is no story for a chat-title lookup error, because the Storybook
query helper cannot inject errors.
- Codex review: 4 rounds (8, 4, 4 and 6 P2 findings, no P0 or P1).
- Rounds 1 to 3 were fixed, except the model-availability item
(CODAGT-1244).
- Round 4 found no blocker and is tracked in CODAGT-1246, together with
the minor UAT round 2 findings.
- All threads are resolved. There is no clean Codex verdict on the
current head. Further rounds were not requested because findings were
not converging and none was a blocker; the stack orchestrator accepted
stopping at round 4.
- CI: `ci` run 36703512580, started with workflow_dispatch, is green on
the current head `b37e9d99d0`. Pushes to existing stacked PRs did not
start the pull_request `ci` run (noted in the comments). The earlier
head `8f2ee30d8f` was green through a normal pull_request run.
Size: about 1,370 hand-written lines (about 560 of them tests and
stories), plus generated code. This is over the 1,000-line guideline,
mostly from review fixes.
## Stack
Stacked on #30085, #30096, #30112, #30117, #30127, #30134, #30160,
#30166 and #30167 (CODAGT-1215). Base:
`tk/codagt-1215-automations-chat-labels`, merged in (not rebased).
Follow-ups: CODAGT-1244, CODAGT-1246.
---
_Generated with [`xum`](https://github.com/coder/xum) • Model:
`anthropic:claude-opus-5-5` • Thinking: `high`_
|
||
|
|
b96f1b970c |
feat: label automation messages in agent chats (#30167)
Closes CODAGT-1215. Part of CODAGT-1135 (Automations for Coder Agents,
RFC step 9).
Chat messages and queued inputs delivered by a chat automation (webhook,
schedule, Run now) now show a label: `Automation run · <automation name>
· input <first 8 chars of input ID>`. A tooltip holds the full
automation and input IDs. While names load, the label omits the name
part. When the name cannot be resolved (deleted automation, a
shared-chat viewer who cannot read it, or experiment off), the label
shows the automation ID instead. Ordinary messages have no label.
## Changes
- **Backend (minimal, SDK exposure only):** `codersdk.ChatMessage` and
`codersdk.ChatQueuedMessage` gain `automation_id` and `input_id`
(omitted when unset). `db2sdk` fills them from the existing columns, so
REST messages and the stream `message` and `queue_update` events carry
them. No behavior change in the lower layers.
- **Frontend:** `API.experimental.getChatAutomations`, a
`chatAutomations` query, and `useChatAutomationNames`. The hook fetches
`GET /api/experimental/organizations/{org}/chat-automations` only when
the user-scoped `chat-automations` experiment is on and the chat holds
automation input. The `AutomationLabel` component uses the shared
`Badge` and `Tooltip`, and is wired into `ConversationTimeline`
(history) and `QueuedMessagesList` (queue). The chat store refetches
names when new automation input arrives, so automations created or
renamed after page load show their current name.
- Out of scope, per the ticket: the occurrence label and the
requested-versus-resolved effort display.
## Validation
- Vitest: the automations list is requested for the chat's organization
only when the chat holds automation input and the experiment is on;
`useChatAutomationNames` reports loading until the list resolves and
then maps IDs to names; the chat store refetches names on new live
automation input. Go: `TestChatMessageAutomationProvenance` for both
converters.
- Storybook (Pixel): `ConversationTimeline/AutomationUserMessages` and
`QueuedMessagesList/AutomationMessages` (named, deleted by ID, long name
at phone width, no label on ordinary items) and
`QueuedMessagesList/AutomationMessagesLoading` (name still loading: no
UUID flash).
- Remote dogfood UAT on a develop.sh instance with the experiment on:
PASS in round 2. It covered webhook input in an existing chat (history
and queue), a schedule, a new_chat first message, the ID fallback after
deletion, and no label on ordinary messages. Screenshots are in a
comment below. Run now was not on the base branch during UAT; it uses
the same fields and path.
- coder-frontend-review self-review: all roles PASS, after fixes on each
update.
## Known limitations (follow-ups under CODAGT-1135)
- A shared-chat viewer who does not own the automation sees its ID,
because automation RBAC has no chat ACL (CODAGT-1239).
- Copying the label text yields three lines, because the name span
truncates separately (CODAGT-1238).
## Stack
Stacked on #30085, #30096, #30112, #30117, #30127, #30134, #30160 (1211
7a) and #30166 (1211 7b). Base: `tk/codagt-1211b-automations-run-now`.
---
_Generated with [`xum`](https://github.com/coder/xum) • Model:
`anthropic:claude-opus-5-5` • Thinking: `high`_
---------
Signed-off-by: Thomas Kosiewski <tk@coder.com>
|
||
|
|
b25f8859f2 |
feat: add Run now for schedule chat automations (#30166)
Closes CODAGT-1211. Part of CODAGT-1135. > Stack: PR 7b of "Automations for Coder Agents", on top of 7a (#30160, the schedule scanner), which sits on 1210 5b (#30134). Adds Run now for schedule automations: `POST /api/experimental/organizations/{organization}/chat-automations/{automation}/runs` publishes the saved prompt at once through the existing `Publish` path, with no occurrence. It never writes the automation row, so the schedule cursor and revision stay unchanged. - **Owner-only.** `chatd.RunAutomation(ctx, actorID, id)` compares the caller with the automation owner before anything else, so org admins and site owners get 403 even though dbauthz lets them read and write the row (CODAGT-1226). A user who cannot read the automation gets 404, and the route sits behind the experiment gate, so a caller with `chat-automations` off gets 404. `Publish` also checks the owner's experiment again. - **Statuses.** 202 with `input_id` and `chat_id`; 400 for a non-schedule automation; 409 for a disabled schedule, a busy chat with When busy `skip`, or an unavailable target or model; 429 when the chat queue or the automations' share of it is full; hook denials use the same response as chat messages. - **new_chat.** A Run now of a new_chat schedule creates a chat titled with the run time in the schedule's time zone and records the same audit entry as webhook-created chats. ## Tests `coderd/exp_chat_automation_runs_test.go` runs against a real coderdtest server: the owner's run saves one message with the returned input id and leaves the whole automation row byte-equal; org admin and site owner get 403 (also on a webhook automation, proving the owner check comes first) and a non-reader gets 404, with nothing saved; webhook 400, disabled 409, busy `skip` 409, queue share 429; new_chat title, owner, and audit entry. The experiment gate test covers the new route. Dogfood UAT ran on a real dev instance through Coder Agents and passed: immediate publish with the cursor and revision unchanged, 409/429 refusals, 403 for an org admin and the site owner, 404 with the experiment off, and a one-minute schedule that kept one message per minute around a Run now. ## Size About 325 hand-written lines (about 190 of them tests). Generated: `coderd/apidoc/docs.go`, `coderd/apidoc/swagger.json`, `docs/reference/api/schemas.md`, `site/src/api/typesGenerated.ts` (213 lines). ARCHITECTURE.md prose was drafted by an agent at the user's request; the user will review it. Also replaces the CODAGT-1209 ARCHITECTURE.md TODO from #30117; the prose was drafted by an agent at the user's request, and the user will review it. --- _Generated with [`xum`](https://github.com/coder/xum) • Model: `anthropic:claude-opus-5-5` • Thinking: `high`_ |
||
|
|
b517db4beb |
feat: deliver webhook events to existing chats through chat automations (#30127)
Part of CODAGT-1210 (1 of 2). Part of CODAGT-1135. > Stack: PR 5 of "Automations for Coder Agents", on top of #30117. The ticket is split in two by operation: this PR delivers webhook events to `existing_chat` targets; the stacked follow-up delivers them to `new_chat` targets and closes CODAGT-1210. Until then a `new_chat` automation's events endpoint answers `501`. ## What this adds - `POST /api/experimental/chat-automations/{automation}/events`. External systems send the automation's webhook secret as `Authorization: Bearer <secret>` and a JSON body of at most 256 KiB. The route has no API key middleware and sits outside the `/api/experimental` group, behind its own rate limiter keyed by caller and a fixed endpoint key (IP address for unauthenticated callers), so varying the automation id does not reset the budget. - Secret check: SHA-256 of the bearer value, compared in constant time. Unknown ids, other kinds, and wrong secrets all get the same `401`. The `chat-automations` experiment is checked for the automation owner only after the secret matches (`404` when off). The body is then read: over the limit `413`, not JSON `400`. - `chatd.PublishAutomationWebhook` sends as the owner (`dbauthz.As` with the owner's subject) through `SendMessage` with the `queue` busy behavior set explicitly, so automations never interrupt or steer. `user_prompt_submit` hooks run first: a denial is `403`, an unreachable hook service `502`. - One admission check runs before the send (so refused events never reach hooks) and again in the `AdmitInTx` callback, which locks the automation together with the chat's queued automations in one ascending-order call. Under the lock it rechecks: enabled, secret version (a request verified before a rotation but committed after it gets `401`), single-use state, target chat (root chat of the owner, same org, not archived), owner status, and the owner's `chat:update` permission. It then applies **When busy**: `skip` refuses a busy chat (`409`), `queue` refuses input beyond the automations' share, half the chat queue cap rounded down and at least 1 (`429`); busy and the share count only queued rows that promotion would still deliver. It marks a single-use webhook consumed and returns the provenance. - The message has two parts: the saved prompt, and a labeled part with the body as untrusted event data inside `<automation_event_data>` tags. `json.HTMLEscape` escapes `<`, `>`, and `&` in the body, which keeps the JSON value and makes the closing tag impossible to forge. - `chatd.Config.Authorizer` (wired from `options.Authorizer`) for the explicit owner checks; publishing fails closed without one. - New query `ConsumeChatAutomationWebhookByID` with a dbauthz wrapper. Status codes follow the RFC's failure outcomes table; the chat-without-a-model case returns the same `400` as a person's message. ## Notes for reviewers - Single-use consumption runs from the chatd publish code as the owner, because the chatd role only reads `chat_automation`. No lower-layer RBAC change. - ARCHITECTURE.md prose was drafted by an agent at the user's request; the user will review it. - Size: about 1,460 hand-written lines after review fixes (about 770 of them tests), over the ~1,000 budget because of the review hardening. Generated: about 360 lines (`coderd/apidoc`, `dbmock`, `dbmetrics`, `querier.go`, `queries.sql.go`, `docs/reference/api/schemas.md`, `typesGenerated.ts`). - Dogfood UAT ran through Coder Agents on a real dev deployment with curl deliveries. Round 1 found error-mapping defects, fixed here; rounds 2 and 3 passed, the last on the final code (the head after it changes only ARCHITECTURE.md). - Deferred: CODAGT-1233 (stale automation rows filling the physical queue cap; lower-layer `SendMessage` path). --- _Generated with [`xum`](https://github.com/coder/xum) • Model: `anthropic:claude-opus-5-5` • Thinking: `high`_ |
||
|
|
5c1662ea4c |
feat: disable, re-enable, and rotate chat automations with schedule preview (#30117)
Completes the chat automations management API from RFC step 3: disable and re-enable, delete that disables first, webhook secret rotation, and a server-side schedule preview. Stacked on #30112. - **Disable** (`PATCH` with `{"enabled": false}`) runs in two steps. A short transaction that touches only the automation row sets `enabled = false` and increments `queue_generation`, the cutoff. After it commits, the automation's queued rows below the cutoff are deleted one chat at a time through chatd's existing `DeleteQueued` transition, run as chatd, so queue versions and stream updates match a manual delete. If a row is missed, for example after a crash between the steps, the queue promotion guard from #30096 discards it, because its generation is stale. Running turns are not interrupted. - **Delete** deletes the row and then removes all of the automation's queued rows the same way. Deleting the row is itself the cutoff, because the promotion guard discards rows whose automation no longer exists. So delete needs only delete permission, not update. This differs from the RFC's "disable, then delete" order, with the same outcome. - **Re-enable** (`{"enabled": true}`) moves a schedule's cursor to the next future cron time, so the disabled period is not replayed. The generation never resets. - **Permissions:** only the owner can enable, edit, or rotate. Organization admins and site owners can send exactly `{"enabled": false}` (anything combined with it is 403), and can still list, read, and delete. - **Rotation:** `POST .../chat-automations/{automation}/secret/rotate` (owner only, webhooks only) returns the new secret once and increments `webhook_secret_version`. Only the SHA-256 hash is stored, and the rotation is audited with the hash redacted. - **Preview:** `POST .../chat-automations/schedule-preview` evaluates an unsaved cron expression and time zone with create's rules and returns the next five run times, or 400. - `coderd/x/chatd/ARCHITECTURE.md` gets a `TODO (CODAGT-1209)` note about disable using the delete-queued transition. **Author action before merge:** replace that TODO with the architecture prose (agents do not write that document). Known gap, tracked in CODAGT-1227: when the target chat is archived, disable and delete cannot remove its queued automation rows, because `DeleteQueuedMessage` is not allowed from archived states. The rows never run, since the promotion guard discards them, but they stay visible after the chat is unarchived. The fix needs a chatstate transition from the lower layer. Dogfood UAT ran on a real dev instance and passed. It covered disable removing only that automation's queued rows (the chat API agreed), delete, re-enable without replay, the permission matrix for an organization admin and the site owner, rotation (the stored hash matches the new secret, and neither secret appears in get or list), preview, and a runtime experiment rule. It also checked that a leftover row is discarded on promotion. Closes CODAGT-1209 Part of CODAGT-1135 Refs CODAGT-1217 Stack: PR 3b of the Automations for Coder Agents stack, on top of #30112 (PR 3a), #30096, and #30085. > This PR was written by an AI agent (xum) and reviewed by the agent's own test audit and UAT. A human has not reviewed it yet. --- _Generated with [`xum`](https://github.com/coder/xum) • Model: `anthropic:claude-opus-5-5` • Thinking: `high`_ --------- Signed-off-by: Thomas Kosiewski <tk@coder.com> |
||
|
|
9316d67440 |
feat: add chat automations management API behind chat-automations (#30112)
Adds the management API for chat automations under
`/api/experimental/organizations/{organization}/chat-automations`,
behind the new user-scoped `chat-automations` experiment. This is the
first of two PRs for RFC step 3; nothing publishes automation messages
yet.
- **Experiment:** `chat-automations` is in `ExperimentsKnown`,
`ExperimentsUserScoped`, and the ruleguard list in `scripts/rules.go`.
Every route asks `chatd.AutomationsEnabled(ctx, api.ExperimentEvaluator,
callerID)`, which fails closed on a missing subject or evaluator; the
routes stay mounted and return 404 when the experiment is off for the
caller, so a runtime rule for one user applies on the next request
without a restart. There is no `/api/v2` alias.
- **Routes:** list, create (201), get, `PATCH`, delete (204), with
Swagger annotations and audit entries. List returns the automations in
the organization the caller can read (members see their own,
organization admins see all).
- **Service** (`coderd/x/chatd/automations.go`): create validates kind
and target shape, a non-empty prompt, a five-field cron and IANA time
zone, model access, and that an `existing_chat` target is a root chat of
the owner in the same organization. It defaults `when_busy` to `skip`
for schedules and `queue` for webhooks and computes the first schedule
cursor. `PATCH` runs the same per-field validation on each changed
field, rejects `kind` and `target_mode`, bumps `schedule_revision` on
prompt, cron, or time zone changes, and recomputes the cursor on cron or
time zone changes.
- **Owner-only:** only the owner can `PATCH` an automation, even with
organization-admin or site-owner roles (403); admins can list, read, and
delete.
- **Secrets:** a webhook's secret (`coder_automation_` prefix) is
returned once in the create response. Only its SHA-256 is stored, and it
appears in no list, get, audit, or log output.
- **Cap:** new option `--chat-max-automations-per-owner` (default 50)
caps automations per owner across all organizations; creating one more
returns 409. Creates serialize on a per-owner advisory lock.
- **Cron:** `cron.Standard(spec, timeZone)` accepts any standard
five-field expression (the existing `Weekly` rejects day-of-month and
month restrictions). Responses include the next five run times of an
enabled schedule.
PR 3b (stacked on this one) adds disable and re-enable with the queue
cutoff, makes delete run disable first, and adds secret rotation and the
schedule preview route. Until then, the queue promotion guard from
#30096 discards queued rows whose automation was deleted.
Dogfood UAT ran on a real dev instance and passed:
create/list/get/patch/delete via curl, owner-only 403s for an
organization admin and the site owner, the cap (including concurrent
creates and cross-organization counting), a runtime rule turning the
experiment off for one user without a restart, and `/api/v2` 404s.
Part of CODAGT-1209 (PR 3b closes it)
Part of CODAGT-1135
Refs CODAGT-1217
Stack: PR 3 of the Automations for Coder Agents stack, on top of #30096
(which is on top of #30085).
> This PR was written by an AI agent (xum) and reviewed by the agent's
own test audit and UAT. A human has not reviewed it yet.
---
_Generated with [`xum`](https://github.com/coder/xum) • Model:
`anthropic:claude-opus-5-5` • Thinking: `high`_
---------
Signed-off-by: Thomas Kosiewski <tk@coder.com>
|
||
|
|
f55aa6c50d |
feat: add chat automations schema, RBAC resource, and audit entries (#30085)
Adds the storage and authorization pieces for Automations for Coder Agents. No route, SDK request type, or chatd code uses them yet, so nothing is exposed. This is the bottom PR of the Automations stack (RFC step 1). Later PRs add the chatd acceptance seam, management routes, webhooks, and schedules on top of these names and constraints. **Schema** (migrations 000609, 000610) - `chat_automations` table with enums `chat_automation_kind`, `chat_automation_target_mode`, `chat_automation_webhook_use`, and `chat_automation_when_busy`. It includes `created_by_chat_id`, the webhook secret hash and version, the single-use `webhook_consumed_at` marker, the schedule cursor and revision, and `queue_generation`. Named CHECKs enforce the target and kind shapes from the RFC. A composite foreign key keeps `new_chat_model_config_id` in the automation's organization, the same pattern the model override tables use. A trigger (`chat_automations_chat_organization`) keeps `target_chat_id` and `created_by_chat_id` in that organization too. A composite foreign key cannot do that while keeping `ON DELETE SET NULL` on PostgreSQL 13. The trigger validates a reference only on insert or when it changes, so chat deletion can still clear both references. Indexes cover the owner and both chat references for cascades and `SET NULL`. - Provenance columns with partial indexes and no foreign key to `chat_automations`: `automation_id`, `input_id`, `queue_generation` on `chat_queued_messages` (all set or all null), `automation_id` and `input_id` on `chat_messages`, and `chats.automation_id`. `chats_expanded` is recreated to include `automation_id`. - `chat_automation` values for `api_key_scope` and `resource_type`. The down migration is a no-op because enum values cannot be dropped. **Authorization** - New organization-scoped RBAC resource `chat_automation` (create, read, update, delete). The `agents-access` role grants it for the member's own automations. It is excluded from the member role's user-level permissions, so a member without `agents-access` gets nothing. Site owners and organization admins get it through their existing all-permissions lists. The owner-only update, enable, and run rule from the RFC belongs to the management service in a later PR. - The generated scopes stay out of `externalLowLevel`, so API keys gain no user-requestable scopes. - `dbauthz` wrappers for the three queries this PR adds: `InsertChatAutomation`, `GetChatAutomationByID`, and `DeleteChatAutomationByID`. `InsertChatAutomation` also requires update on the target chat, read on the creating chat, and read on the new-chat model config (its user and group ACL). There is also a `dbgen.ChatAutomation` helper. **Audit** - `enterprise/audit/table.go` entries for `ChatAutomation`, with `webhook_secret_hash` and `prompt` marked `ActionSecret`. The prompt is treated as chat content, like chat titles. The schedule cursor, revision, and queue generation are ignored as internal bookkeeping. `Chat.automation_id` is tracked. **Required checks from the ticket** - Migrations apply and roll back: `TestMigrate` and `TestMigrateUpWithFixtures` (new fixture for 000609). Dogfood UAT also applied the migrations on a dev instance, rolled them back, re-applied them, and compared schema dumps. After rollback, the only differences from main were the enum values that cannot be dropped and develop.sh's own `_develop` schema. After re-applying, the only difference from this branch's `dump.sql` was the `_develop` schema. - Secret hash marked secret: `Test_chatAutomationSecretFieldsRedacted` checks the table entries and that an audit diff contains neither the raw hash, its base64 form, nor the prompt text. Also covered: `TestRolePermissions` cases for own, other owner, other organization, and a member without `agents-access`. `TestChatAutomationShapeConstraints` covers the named CHECKs, the cross-organization foreign key and trigger, a cross-organization retarget, and deleting referenced chats. Under `site/`, only generated files changed (`typesGenerated.ts`, `rbacresourcesGenerated.ts`). Closes CODAGT-1207 Part of CODAGT-1135 --- _Generated with [`xum`](https://github.com/coder/xum) • Model: `anthropic:claude-opus-5-5` • Thinking: `high`_ --------- Signed-off-by: Thomas Kosiewski <tk@coder.com> |
||
|
|
1ad46e48ac |
feat: report port-forward sessions as app usage (#30156)
`coder port-forward` reported usage with the deprecated `UpdateWorkspaceUsageContext`. It now reports a `port_forwarding` session, like `coder ssh` and the VS Code SSH path, but only while a forwarded TCP connection is open. **Behavior change:** CLI output is unchanged. Port-forward sessions previously only bumped the workspace's last-used time. With the hidden `workspace-usage` experiment enabled, the server now also records `port_forwarding` session counts under a new `port_forwarding` family, which the deployment banner totals under **Other**. Without the experiment, `postWorkspaceUsage` returns 204 before reading the body, so nothing changes. <details> <summary>Decisions</summary> - Added `codersdk.UsageAppNamePortForwarding` (`port_forwarding`) rather than reusing `ssh`, so port-forwarding isn't counted as interactive SSH. The name matches the arbitrary app names RFC's connection-method name. - Registered a `port_forwarding` family in `codersdk/appname.go`. Families resolve at read time, so no data migration is needed. Template insights list apps individually; telemetry, metricscache, and agentstats gauges are legacy fixed fields and stay as they are. The Prometheus insights family is left to #29906. - Only TCP connections count. UDP forwards never see EOF, so one datagram would keep the session active until exit. - Reports once at startup, like the old call, then every minute and once on shutdown. An idle tick sends an empty body, which still bumps last-used. </details> Closes [CLI-31](https://linear.app/codercom/issue/CLI-31) _This PR was generated by Coder Agents on behalf of @nickvigilante._ <details> <summary>CI note: unrelated test-go-race-pg flake</summary> The `test-go-race-pg` job failed on a data race between `tailnet.(*configMaps).updatePeerLocked` and slog formatting of the same peer value, which does not touch port-forward code. The job was rerun. </details> |
||
|
|
ff158c0589 |
feat: preserve user-supplied chat titles (#29486)
Chats created through the API or MCP couldn't be given a title, and automatic title generation could overwrite a title the user had set, at creation or by renaming during generation. #30254 tried to keep renames by comparing title text, but text can't tell a user title from a generated one that has the same text. Chat creation over the API and MCP now accepts a title. Each chat records where its title came from: fallback (derived from the prompt), generated, or user. A title can only be replaced by a title from the same source or a higher one, so automatic generation never overwrites a user's title. Title changes no longer reorder the chat list, and clients apply them in the order they were written. Chats created before this change are treated as having fallback titles. Closes CODAGT-1047 Reverts #30254 |
||
|
|
7cd1b2040b |
feat: add chat projects API (#29242)
- Experiment, behind `chat-projects` (off by default). First of three stacked PRs: #29301 (memory), #29583 (UI). This PR is API only; the screenshots below are from the UI in #29583. - CRUD under `/api/experimental/organizations/{organization}/chats/projects/{project}`. `GET /api/experimental/chats/projects` lists the caller's projects across all organizations. - `project_id` on chat create and as a chat list filter. A chat joins a project only at creation; there is no move. - Projects are identified by ID. Names are display labels (64 characters, description 1024) with no uniqueness constraint. An optional `icon` URL (usually an emoji image under `/emojis`) is capped at 256 characters and audited. - A user can own at most 100 projects across all organizations; creating another answers 409. Creates count and insert under a per-owner advisory lock so concurrent requests cannot overshoot. - Projects are private to their `owner_id`. Members may only create their own, and a chat can only be bound to a project its owner owns. An unreadable or foreign project on chat create answers 404 so IDs cannot be probed; a project from another organization answers 400. - Permissions ride on the `agents-access` role next to chats (after #30004), so whoever can use Coder Agents can use projects. Owners and org admins reach every project. ### Examples Create a project in an organization: ```http POST /api/experimental/organizations/{organization}/chats/projects {"name": "Platform", "description": "Infra and deploy work", "icon": "/emojis/1f680.png"} ``` ```json { "id": "7c0e4a3e-5b1f-4f7d-9a51-2f3c8f6d2b10", "organization_id": "bb640d07-ca8a-4869-b6bc-ae61ebb2fda1", "owner_id": "0ed9befc-4911-4ccf-a8e2-559bf72daa94", "name": "Platform", "description": "Infra and deploy work", "icon": "/emojis/1f680.png", "created_at": "2026-09-30T15:04:05Z", "updated_at": "2026-09-30T15:04:05Z" } ``` List the caller's projects across organizations with `GET /api/experimental/chats/projects` (an array of the object above). Update with `PATCH .../chats/projects/{project}` and any of `name`, `description`, `icon`; delete with `DELETE`, which detaches its chats. Create a chat in the project, and list only its chats: ```http POST /api/v2/chats {"organization_id": "bb640d07-…", "project_id": "7c0e4a3e-…", "content": [{"type": "text", "text": "Plan the deploy"}]} GET /api/v2/chats?project_id=7c0e4a3e-… ``` At the limit: ```json 409 {"message": "You can have at most 100 chat projects. Delete a project to create another."} ``` <details> <summary>Screenshots (UI from #29583)</summary>      </details> --- Generated with Coder Agents on behalf of @f0ssel. --------- Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com> |
||
|
|
7a9442014e |
feat: add chatd lifecycle stage tracer (#29769)
**TL;DR:** Adds a stage tracer that turns each chat lifecycle stage into
both an OpenTelemetry span and a Prometheus histogram observation, so
traces and metrics always agree. The metrics are only registered with
the `chat-stage-metrics` experiment. Nothing calls the tracer until the
next PRs.
Adds `chatloop.StageTracer`, which emits each chat lifecycle stage as an
OpenTelemetry span and a `coderd_chatd_stage_duration_seconds{stage,
scope, chat_kind}` observation from one `End` call, so trace and metric
durations cannot disagree. The provider-bound stages (`stream`,
`provider_attempt`) are also observed on
`coderd_chatd_model_stage_duration_seconds{stage, provider_type,
chat_kind, model}`, the only family carrying `provider_type` and
`model`, and only for turn-scoped stages. Time to first token per model
stays on the existing `coderd_chatd_ttft_seconds`. Nothing calls the
tracer yet; the next PRs instrument the provider call and the runner.
- The families are registered only when the `chat-stage-metrics`
experiment is enabled (safe and known, so
`--experiments=chat-stage-metrics` or `--experiments=*` turns it on).
Spans are emitted regardless. `NewMetrics` leaves the families off;
`chatd.New` opts in from the experiment, and a test asserts the
experiment decides whether they reach the server's registry.
- `Stage`, `Scope`, `ChatKind`, and `StageAnomaly` are typed string
constants. `scope` separates latency attributable to a prompt (`turn`)
from detached `background` work; `chat_kind` is `root` or `subagent`,
empty without a known chat.
- `StageModel` carries the wire `provider`, `provider_type`, `model`,
and `reasoning_effort`. All are span attributes; only `provider_type`
and `model` are metric labels, on the model family. No family carries an
organization label.
- Observed stages: `chat_turn`, `queue_wait`, `acquisition`,
`mcp_connect`, `stream`, `time_to_first_token`, `provider_attempt`,
`tool_call`, `commit`, `retry_backoff`. `generation_step`, `prepare`,
`thinking`, and `compaction` are span-only. A test keeps the stage sets
and help text consistent.
- API: `Start` / `StartRootAt` for live spans (span timestamps come from
the tracer clock), `Record` for stages reconstructed from timestamps
(the scope comes from the context). `End` is idempotent;
`EndWithoutObservation` ends the span without a sample. A nil tracer,
provider, or metrics discards.
- `coderd_chatd_stage_anomalies_total{reason}` counts observations
dropped, adjusted, or inconsistent (`negative_elapsed`,
`inverted_window`, `missing_timestamp`, `future_start`, `stale_anchor`).
Span-only stages never feed it.
- Buckets are 12 round edges (`0.1 0.25 0.5 1 2.5 5 10 30 60 300 1800
3600`).
- Moves the body of the `for` loop in `StartGeneration` into
`runGenerationStep` so the step has a function boundary for a deferred
stage end. Control flow and error wrapping are unchanged.
<details>
<summary>Series cost (approximate, whole stack)</summary>
A histogram label set is 12 edges + `+Inf` + `_sum` + `_count`: 15
series. Per replica, each `chat_kind` costs about 150 stage series and 4
turn outcome counters; each `(chat_kind, model)` costs 30 (2 stages x
15). Both chat kinds on `M` models: about `308 + 60*M` per replica, plus
background-scope stage series.
Dogfood `main`, 3 replicas: ~3.4k `coderd_*` series per replica (~10.1k
total).
| Models used per replica | Added series (3 replicas) | vs. baseline |
|---:|---:|---:|
| 1 | ~1.1k | +11% |
| 5 | ~1.8k | +18% |
| 10 | ~2.7k | +27% |
| 35 | ~7.2k | +72% |
Most deployments run four or fewer models, so a typical replica adds
roughly 370 to 550 series. The experimental turn accounting in #29772
would add 88 more per replica (11 categories x 4 outcomes x 2 chat
kinds). Series appear lazily and do not grow with organizations.
</details>
<details>
<summary>Review decisions</summary>
- Experiment gate only; no deployment flag or metric levels. If the
experiment graduates, the families become always on like the other chatd
families; a flag is added then only if dogfood shows a cardinality
problem.
- Organization is on neither metrics nor spans, and `effort` is
span-only; `provider_type` (configured type), not the wire `provider`,
is the model-family label.
- `time_to_first_token` is not on the model family; per-model TTFT is
`ttft_seconds`, which observes the same measured window.
- The model family records only turn-scoped stages.
- Nil guards are kept so a nil or zero tracer is always safe to call.
- HTTP attribute keys stay snake_case like the rest of the chatd span
attributes.
</details>
Supersedes #28968 and #28969.
🤖 This PR was generated by Coder Agents on behalf of @jscottmiller.
|
||
|
|
8742d2484c |
feat: add opt-in AI Gateway actor email headers (#29930)
Add opt-in forwarding of the authenticated Coder account email through `--ai-gateway-actor-header-meta-email`, `CODER_AI_GATEWAY_ACTOR_HEADER_META_EMAIL`, or `ai_gateway.actor_header_meta_email`. The option defaults to empty: enabling `send_actor_headers` alone does not forward email. Set a destination header explicitly to opt in; accounts without an email omit it. Carry authenticated email through the Gateway authorization response and strip client-supplied standard/configured email headers before applying trusted identity. The additive protocol field joins unreleased Gateway API v1.3 alongside workspace attribution. Includes email configuration precedence, authorization compatibility, captured upstream request tests, and matching documentation. Refs https://linear.app/codercom/issue/AIGOV-601 Generated with Coder Agents on behalf of @johnstcn. |
||
|
|
05d1fa8a4c |
feat: configure AI Gateway actor identity headers (#29929)
Allows configuring AI Gateway actor ID and username headers independently through `--ai-gateway-actor-header-id` and `--ai-gateway-actor-header-username` or associated environment variables and YAML settings. - Defaults to existing header name, an empty string disables that attribute. - Existing `send_actor_headers` gate remains off by default. - Validates header names, case-insensitive collisions, and protected destinations for embedded and standalone gateways. - Strips standard and configured identity destinations before injecting authenticated values. - Adds coverage for configuration precedence, captured upstream request, and generated help/API documentation. Refs https://linear.app/codercom/issue/AIGOV-601 Generated with Coder Agents on behalf of @johnstcn. |
||
|
|
dd1c836ab0 |
feat: gate the chat board behind a hidden experiment (#30084)
Follow-up to #29425 and #29472. Before this PR, any deployment could turn on the chat board, because it only needed a per-browser opt-in. Now it also needs to enable the experiment. |
||
|
|
12be685b59 |
feat: add experimental API and CLI to manage experiment rules (#29971)
Slice 4 of 4 for runtime experiment rules: an experimental management
API and a hidden CLI, so admins can target, widen, or kill a user-scoped
experiment at runtime without a redeploy. This PR also adds a
startup-default note on the Deployment Overview page and a docs section.
## What's in it
- **API** under `/api/experimental/experiments/rules` (behind
`apiKeyMiddleware` and `httpmw.NoStore`):
- `GET` returns, per user-scoped experiment, the startup default and the
stored rule (mode, condition, revision, actor, time). Stored rules for
other experiments follow, marked `ignored`.
- `PUT /{experiment}` takes `{mode, condition?, expected_revision}`.
- **Write path:**
- It authorizes read and update on `DeploymentConfig` before parsing
anything. A denied request gets 403 and is not audited.
- It validates next. An invalid condition returns 400 with the full CEL
diagnostics, is not audited, and leaves the rule unchanged.
- It then starts the audit and calls `experiments.WriteRule`. A stale
revision returns 409 and a transaction error returns 500; both are
audited with an empty diff.
- An identical write returns 200, creates no audit entry, and keeps the
revision.
- The audit export happens after commit. If it fails, that is logged and
the committed change stands (the existing audit contract).
- **SDK:** `ExperimentalClient.ExperimentRules` and
`ExperimentalClient.PutExperimentRule`.
- **CLI:** hidden `coder exp experiment-rules list|on|off|set|reset`.
- Write commands take `--expected-revision`. Without it they read the
current revision first, which only protects the gap between the two
calls; the help text says so.
- A 409 prints the current rule and exits non-zero, with no retry.
- `reset` warns when the startup default is on, because reset is not a
kill switch.
- **Deployment Overview:** a note says the Experiments values are
startup defaults that runtime rules can override per user.
- **Docs:** a new "Target experiments at runtime" section in
`docs/reference/feature-stages.md` covers the modes, roles, CEL fields
and limits, reset vs. off, revisions and audit, the kill-switch
guarantee (including the rolling-upgrade requirement), frontend
freshness, fail-closed behavior, and that rules are not an authorization
boundary.
## Testing
- **HTTP:** every mode applies on the next request with no restart;
rejected writes keep the rule; RBAC (members 403 on GET and PUT;
auditors can read but not write; an invalid body from an unauthorized
caller still gets 403); malformed and ignored stored rows.
- **HA:** two coderd instances share one database. A PUT through A is
seen by B's `/api/v2/experiments` and by B's evaluator, which is the one
chatd uses.
- **Audit (enterprise, licensed):** an effective change creates one
entry whose diff carries the condition, and the entry is found before
the diff is checked. No-ops, 403s and 400s create no entry. A 409 and an
injected 500 are audited with an empty diff. A failed export keeps the
change.
- **Redaction:** a sentinel condition appears only in the rules API,
audit entries, and the server log's audit lines (Enterprise's slog audit
backend writes every audit diff there). It is absent from every other
log line, `/deployment/config`, the support bundle, and telemetry. The
test wires the slog audit backend so this is checked as stated.
- **CLI:** write and list, a conflict that is not retried, and the reset
warning.
Remote dogfood UAT through Coder Agents passed on a licensed test
deployment:
- the CLI;
- per-user results in the browser;
- 403 for members, including an invalid body;
- group targeting, including removing the user from the group;
- sentinel redaction across logs, `/deployment/config`, the support
bundle and the audit API (at that head the audit still masked the
condition; it is now tracked);
- the audit page showing the condition as changed but masked (same
note);
- the Overview note;
- the static default with `off` and `reset`;
- chatd enforcement toggled between turns.
That round tested `135aaaa41e`. The later commits are a CLI refactor and
a test addition, and a follow-up round will cover the final head.
## Follow-ups (low, not in this PR)
- A broken rule logs one error line per evaluation. Consider
rate-limiting it per experiment and revision.
- There's no API or CLI path to clear a stored rule for an experiment
that isn't user-scoped; those rules are inert and listed as `ignored`.
- A malformed stored rule is listed with zero `updated_by` and
`updated_at` values instead of omitting them.
- CLI wording: the 409 message, conflict output showing a UUID instead
of a username, a no-op write not saying nothing changed, and the parent
help lacking the `user.*` fields.
- `PutExperimentRuleRequest.mode` is not in the Swagger `required` list.
An omitted mode already returns 400.
- The dashboard's experiments query (from #29964) refreshes on mount,
window focus or reconnect once 60 seconds old, not on a timer, and its
comment says it bounds staleness. Correct the comment, or add a refetch
interval if the UI must pick up rule changes without a reload.
## Stack
1. #29869: evaluator library
2. #29898: storage and audit types
3. #29964: enforcement and discovery
4. **This PR:** control plane
> [!NOTE]
> This PR was written by an AI agent (Xum).
---
_Generated with [`xum`](https://github.com/coder/xum) • Model:
`anthropic:claude-opus-5-5` • Thinking: `high`_
---------
Signed-off-by: Thomas Kosiewski <tk@coder.com>
|
||
|
|
a0b00b5e4b |
feat: store experiment rules with revisions and audit types (#29898)
Slice 2 of 4 for runtime experiment rules: persist one rule per experiment in `site_configs`, with revisions that only increase, and add an audit record type. Nothing calls this code yet, so behavior does not change. ## What's in it - **Queries** in `siteconfig.sql`, all checked by dbauthz against `ResourceDeploymentConfig`: - `GetExperimentRules` (read) lists `experiment_rule:` keys with `starts_with`, not `LIKE`, because `_` is a `LIKE` wildcard. - `GetExperimentRule` (read) reads one row. - `UpsertExperimentRule` (update) writes one row. - **`experiments.WriteRule(ctx, db, actor, ex, rule, expectedRevision)`** validates the rule first, then does everything in one `READ COMMITTED` transaction: - It takes an advisory lock for that experiment, waiting at most 5 s. - It reads the current row; a missing row counts as revision 0. - It returns `*RevisionConflictError` when the expected revision is stale. - An identical mode and condition writes nothing and returns `changed=false`. The first `inherit` on a missing row is a change and stores revision 1. - Otherwise it writes `revision+1` with the actor and time, and returns the old and new rule as read and written inside the transaction. - **`experiments.NewDBStore(db)`** implements the evaluator's `Store`. It reads rules by prefix, plus the user's id, username, email, explicit site roles, member org names, and `<org>/<group>` group names (including `<org>/Everyone`). It runs as the system. - **Audit:** - A new `resource_type` enum value `experiment_rule` (migration `000602`; the down migration is a comment because PostgreSQL cannot drop enum values). - A new struct `database.ExperimentRule`. `experiments.AuditRecord` derives its ID from the experiment name, so audit history groups by experiment. - In the audit table, `experiment`, `mode` `revision` and `condition` are tracked (`ActionTrack`), so the audit diff shows the old and new condition. In Enterprise, the slog audit backend also writes that diff to the server log. Admins and auditors can already read the condition through the rules API. - The audit page filter includes the new resource type. ## Testing - `WriteRule` and `NewDBStore` tests run against real PostgreSQL. They cover stale revisions after a reset and a recreate, two concurrent writers with the same expected revision (exactly one wins), no-ops, and rollback after a forced error. - dbauthz method tests and an audit diff test that shows both condition texts. Remote dogfood UAT through Coder Agents passed the upgrade from slice 1 (existing state kept, enum value added), a fresh install, unchanged `/api/v2/experiments`, and the `WriteRule` tests under `-race`. The licensed audit-page check could not run: the test workspace has no premium license. That round tested `015979ca96`. The commit after it only adds `AuditRecord`, and a follow-up UAT round will cover the final head. > [!NOTE] > Migration `000604` was the next free number when this was written. Recheck it before merging. ## Stack 1. #29869: evaluator library 2. **This PR:** storage and audit types 3. Enforcement and discovery (`/api/v2/experiments`, meta tag, chatd `mcp-tool-search`, ruleguard) 4. Control plane (experimental API, `coder exp experiment-rules` CLI, docs) > [!NOTE] > This PR was written by an AI agent (Xum). --- _Generated with [`xum`](https://github.com/coder/xum) • Model: `anthropic:claude-opus-5-5` • Thinking: `high`_ --------- Signed-off-by: Thomas Kosiewski <tk@coder.com> |
||
|
|
813b8c151f |
feat: make AI Gateway content recording optional (#30031)
Add `--ai-gateway-disable-content-recording`, which stops user prompts,
tool
calls and model thoughts from being stored. Cost control reads none of
those
tables, so budgets, spend accounting and enforcement are unaffected.
A dropped record is still logged, so pairing the option with
`--ai-gateway-structured-logging-source=gateway` keeps the SIEM export
for
records that are never persisted. The gateway warns at startup when
content is
dropped while coderd is the only emitter, since those records then reach
neither
the database nor a SIEM.
Covered end to end for the embedded and the standalone gateway, and
documented
alongside cost controls.
<details>
<summary>Why the stack is ordered this way</summary>
The final design is a chain of recorder decorators:
+---------------------+
| AsyncRecorder | all records except the interception start
+---------------------+
| LogRecorder | emit the structured record
+---------------------+
| ValidatingRecorder | refuse malformed records
+---------------------+
| caller middleware | record policy, e.g. drop content
+---------------------+
| TraceRecorder |
+---------------------+
| DRPCRecorder | acquire client, send to coderd
+---------------------+
Ordering constraints:
- The record type constants (1) are the vocabulary both emitters and the
validator use, so they come first.
- Validation (5) rejects unset timestamps, so records must already be
stamped
where they are created (3). Stamping at creation leaves
`WrappedRecorder`
doing nothing but client acquisition, which is why it is folded into
`DRPCRecorder` (4) and not before.
- coderd's server-time fallback (2) is what keeps a gateway of an older
version
from persisting zero times once the gateway owns stamping (3).
- PRs 1 to 5 change no user-visible surface. Each deployment option then
lands
with the code that reads it: the log source with gateway-side emission
(6),
content recording with the filter that drops the records (7). Pool
options are
plumbed to the serving pool in 6, where the first option that needs them
arrives, rather than as an unused hook beforehand.
</details>
---
🤖 Raised by [Coder Agents](https://coder.com) on behalf of @SasSwart.
|
||
|
|
23fb35d185 |
feat: let the AI Gateway emit the structured interception records (#30030)
coderd emitted the structured interception records as they arrived over
DRPC, so
a record the gateway never sends cannot be exported.
- Add `--ai-gateway-structured-logging-source` (`coderd`, `gateway`,
`both`) and
teach the gateway's `LogRecorder` to emit the same format where the
records
originate. Gateway lines omit `thread_parent_id` and `thread_root_id`,
which
are resolved by a database lookup only coderd can perform.
- Reaching the serving pool required repairing the pool options: they
were
derived at construction sites and discarded, so the server always built
its
pool with the defaults. They are now derived from the deployment
configuration
in one place and passed to the pool that serves requests. The server
reports
those options, and its ownership of the `key_pool_state` collector, so a
second
registration cannot silently reappear and panic startup.
- The standalone gateway inherits both structured logging options, since
it is
now one of the processes that can emit.
This is the keystone of the stack: the flag, the mechanism that carries
it and
the behavior it selects land together, so
`TestAIGatewayStart_InheritedOptions`
and the gateway help output stay truthful at every commit.
<details>
<summary>Why the stack is ordered this way</summary>
The final design is a chain of recorder decorators:
+---------------------+
| AsyncRecorder | all records except the interception start
+---------------------+
| LogRecorder | emit the structured record
+---------------------+
| ValidatingRecorder | refuse malformed records
+---------------------+
| caller middleware | record policy, e.g. drop content
+---------------------+
| TraceRecorder |
+---------------------+
| DRPCRecorder | acquire client, send to coderd
+---------------------+
Ordering constraints:
- The record type constants (1) are the vocabulary both emitters and the
validator use, so they come first.
- Validation (5) rejects unset timestamps, so records must already be
stamped
where they are created (3). Stamping at creation leaves
`WrappedRecorder`
doing nothing but client acquisition, which is why it is folded into
`DRPCRecorder` (4) and not before.
- coderd's server-time fallback (2) is what keeps a gateway of an older
version
from persisting zero times once the gateway owns stamping (3).
- PRs 1 to 5 change no user-visible surface. Each deployment option then
lands
with the code that reads it: the log source with gateway-side emission
(6),
content recording with the filter that drops the records (7). Pool
options are
plumbed to the serving pool in 6, where the first option that needs them
arrives, rather than as an unused hook beforehand.
</details>
---
🤖 Raised by [Coder Agents](https://coder.com) on behalf of @SasSwart.
|
||
|
|
d853893e8a |
feat: filter agent chats by chat status (#30009)
> 🤖 This PR was written by Coder Agents on behalf of Jake Howell. The sidebar's `Chat status` filter only offered `Read`/`Unread`. This turns it into a real status filter backed by the `chat_status` enum, the same value the row icon already shows. Stacked on #30006. - New `status:<waiting|running|error|requires_action|interrupting>` search filter (repeated or comma-separated) plus a `chat_statuses` param on `GetChats`. - Sidebar `Status` submenu offers `Requires action`, `Error`, `Working` and `Idle`; `Working` covers `interrupting`, since stopping a turn is too brief to be worth its own option. A full selection emits no filter. - `Unread` moves out to its own checkbox (`unread=true` in the URL), so it narrows a status selection instead of competing with it. - Grouping by status now sections by the five statuses instead of `Unread`/`Read`, reusing `getChatStatusDisplay` for labels and icons. <img width="439" height="177" alt="image" src="https://github.com/user-attachments/assets/82ef2ef0-cde9-4169-bb29-caa7b9bfdb9e" /> |
||
|
|
f5092aaa4a |
feat: make chat limits configurable deployment options (#28927)
Adds deployment options for the chat limits that shape turn behavior and API acceptance, replacing hardcoded constants in `coderd/x/chatd` and the chat API. Defaults are unchanged. | Option | Default | Limit | |---|---|---| | `CODER_CHAT_MAX_STEPS_PER_TURN` | 1200 | steps (model responses) in a chat turn | | `CODER_CHAT_MAX_GENERATION_RETRIES` | 25 | consecutive retries after a model generation fails with a transient error | | `CODER_CHAT_MAX_QUEUED_MESSAGES_PER_CHAT` | 20 | messages that can be queued in a chat | | `CODER_CHAT_MAX_ATTACHMENTS_PER_CHAT` | 50 | files linked to a chat; linking more deletes the earliest uploads | | `CODER_CHAT_MAX_PROMPT_BYTES` | 131072 | system prompt, plan mode instructions, and each user's custom prompt | | `CODER_CHAT_MAX_CONCURRENT_RECORDING_UPLOADS` | 25 | desktop recordings each server stores at the same time | `codersdk.DefaultChat*` constants remain the single source of truth. Values below 1 fail startup validation, and each option's description ends with "Must be at least 1." `chatd.New` fills any zero field in `chatd.Config.Limits` with its default once, `LimitsFromConfig` is a plain conversion, and the code that receives a limit as a parameter (the `chatstate` queue and file link checks, the turn step check, `chatretry.Retry`, and `chatadvisor.NewRuntime`) returns an error for a limit below 1 instead of choosing a default or disabling the limit. The options are documented in the generated configuration reference and in the platform controls docs. `CODER_CHAT_MAX_GENERATION_RETRIES` counts consecutive retries, and the count resets after each successful step. The default allows 25 retries (26 attempts) where the old constants allowed 24. The same limit now applies to each nested advisor model call and to background title, summary, and turn status label generation, which previously used fixed `chatretry` budgets. Chat creation and tool result bodies keep the fixed 256 KiB limit from main. The prompt-saving endpoints accept bodies up to twice the prompt limit, for JSON escaping and characters that sanitization removes, but never less than 256 KiB, so small prompt limits still return the 400 length error. At the default this equals the 256 KiB limit on main. Four settings from earlier revisions were removed, and the fixed limits from main are back: - `CODER_CHAT_MAX_TOOL_OUTPUT_BYTES`: the agent already keeps a 16 KiB head and a 16 KiB tail of command output, so raising it had no effect and lowering it cut the tail. - `CODER_CHAT_MAX_DYNAMIC_TOOLS_PER_CHAT`: tool definitions share the 256 KiB chat creation body limit, so raising the count did little. - `CODER_CHAT_DEBUG_MAX_BODY_BYTES`: one setting covered two unrelated debug caps. - `CODER_CHAT_DEBUG_MAX_TEXT_RUNES`: the name did not say what it applied to. Root and subagent concurrency caps stay fixed because they are licensing behavior, and `MaxChatFileSizeBytes` stays fixed because the web UI hardcodes the generated constant for client-side checks. `codersdk.MaxChatFileIDs` is removed; the web UI's "Attachment expired" tooltip no longer quotes the number because the cap is now per deployment, and it says that attaching a file beyond the limit permanently deletes the chat's earliest-uploaded attachments. ## Review record | Round | Reviewed head | Result | Disposition | |---|---|---|---| | Codex 1 and 2 (Sep 2 to 3) | `7f10a1572f8`, `8ee09f8fa3b`, `197bb78d5b` | 10 findings, then OK on `197bb78d5b` | all threads resolved | | Codex 3 (Sep 17) | `e4efac249a5` (pre-rebase) | 4 findings | advisor retry limit confirmed and fixed in `9e462b7b3d0` (rebased from `67341e458e8`); ARCHITECTURE.md TODOs added; JSON-escaping body sizing and streamed-argument rune cap declined as pre-existing design (evidence in threads) | | Codex 4 (Sep 18) | `9e462b7b3d0` | 6 findings | recording evicted at attachment cap 1 confirmed and fixed in `5b61895decb`; `Limits` field docs and zero-value fallback documented; prompt retro-enforcement, generated multi-sentence lines, and tool-output truncation metadata declined as pre-existing design (evidence in threads) | | Codex 5 (Sep 18) | `5b61895decb` | 1 finding | over-cap batch of already-linked files accepted after lowering the cap: confirmed and fixed in `f44063e74e5` | | mafredri (Sep 23) | `f44063e74e5` | 24 threads, changes requested | all fixed in `05e3e3d622a`, `c1f78e09e8b`, `709ddb67977`, `d0587a49829`, `ca4347b24de`, and `1f6c9e2a46f`, then answered and resolved; the ARCHITECTURE.md text was written at the author's direction and approved by the author | | Sibling sweep (Sep 24) | `1f6c9e2a46f` | author-requested audit of all 24 mafredri threads for sibling issues, plus a test refactor | fixed in `37eaf07d34d` through `1f14ac041b7`: the advisor retry limit, `chatretry.Retry`, and the turn step check reject values below 1 instead of disabling retries or the limit; limit tests run against both the default and configured values set through `chatd.Config` or `DeploymentValues`; the expired-attachment tooltip is concrete. A required coder-frontend-review run (8 roles in one agent, CD re-run once) found a stale story comment, removed. | | Codex 6 (Sep 27) | `a71383e3a31` | OK, no findings | requested after the rebase at the author's direction, past the six-pass review budget | The branch was rebased onto main `4851c7b60c8` on Sep 27; the previous head was `91b84000adb`, and the earlier SHAs in the review record predate the rebase. Conflicts in the `chatstate` transitions and `CreateChat` keep both main's `InitialStatus` and this PR's `MaxFileLinks`, and main's rewrite of `advisor_internal_test.go` in #28754 keeps main's version plus this PR's limit tests. Two tests added on main needed the new retry arguments: `TestGenerateStructuredTitleWithUsage_FallsBackToTextWhenToolChoiceRejected` and `TestAdvisorRunStreamsReasoningDeltasSeparatelyFromAdvice`. Validation on `a71383e3a31`: the pre-commit hook (generation, golangci-lint, build), the full `coderd/x/chatd/...` suite (20 packages), the chat tests in `codersdk`, `coderd`, and `enterprise/coderd`, the CLI help tests, race-detector runs of the `chatd`, `chatstate`, `chatadvisor`, and `chatretry` packages, and `go build` plus `go vet` on each of the 27 commits. No remote UAT was run. > Xum acted on behalf of @ibetitsmike for this pull request. |
||
|
|
4f2fd36e8f |
feat: add pr_status:none filter for chats without a pull request (#30006)
> 🤖 This PR was written by Coder Agents on behalf of Jake Howell. Adds `none` to the `pr_status` chat filter, matching chats with no linked pull request. Stacked on #30005. - `none` means no diff-status row, or a row whose `pull_request_state` is null/empty (so chats whose PR was cleared still match), and it ORs with the other statuses, e.g. `pr_status:none,open`. - Frontend picks it up from the shared `CHAT_LIST_PR_STATUS_ORDER`, shown as `No PR`; `searchQuery.ts` now derives its valid set from that list instead of a duplicated literal. - Swagger, API docs and the `list_chats` tool schema regenerated/updated. <img width="508" height="464" alt="image" src="https://github.com/user-attachments/assets/bd6c70e3-c634-499d-ae16-e7953f6da2f9" /> |
||
|
|
cdf50f8b2c |
feat: add mark as read and unread to agent chat menus (#30015)
> 🤖 This PR was written by Coder Agents on behalf of Jake Howell. The chat read cursor only moved when a chat's stream connected or disconnected, so there was no way to clear an unread dot without opening the chat, or to flag a chat to come back to. `UpdateChatRequest` gains a `read` field that either advances the owner's read cursor to the latest assistant message or clears it, and the agents sidebar exposes it as a **Mark as read** / **Mark as unread** item directly under **Show subagents** in both the right-click and the ⋮ menus. Notes: - The cursor is owner-scoped, so `PATCH /api/v2/chats/{chat}` returns 403 for `read` when the caller is not the owner, even when they may otherwise update the chat. - The item is hidden for the chat that is already open, because opening a chat marks it read and would immediately undo the toggle. That also matches the sidebar, which never shows an unread dot for the active chat. <img width="292" height="215" alt="image" src="https://github.com/user-attachments/assets/31e9e249-70ea-4582-9391-66c4c51621b9" /> <details> <summary>Implementation notes</summary> Backend: - `UpdateChatLastReadMessageID` takes a nullable `last_read_message_id`; `NULL` clears the cursor so every assistant message counts as unread again. - `markChatAsRead` (stream connect/disconnect) now wraps `advanceChatReadCursor`; `clearChatReadCursor` is the new unread path. Both return errors so the HTTP handler can report failures instead of only logging them. Frontend: - `markChatRead` / `markChatUnread` mutations mirror `pinChat` / `unpinChat`: optimistic `has_unread` update, rollback plus invalidation on error, invalidation on settle. - `onMarkChatRead` / `onMarkChatUnread` thread from `AgentsPageLayout` through `ChatsSidebar` → `ChatsPanel` → `ChatTreeContext` → `ChatTreeNode`. `ChatTopBar` deliberately does not pass them, since it only ever renders the active chat's menu. Checks run: `make gen`, `make fmt`, `golangci-lint run ./coderd/...`, `go test ./coderd -run TestChatReadState`, `go test ./coderd -run 'TestSharedReaderStreamChat|TestChatPinOrder'`, `go test ./coderd/database -run TestChatHasUnread`, `go test ./coderd/database/dbauthz -run TestMethodTestSuite`, `tsc --noEmit`, `biome check`, and the AgentsPage Vitest unit and Storybook projects. </details> |
||
|
|
4f372cef02 |
feat: accept include_related on get workspace by owner and name (#29855)
Adds `include_related` support to `GET
/api/v2/users/{user}/workspace/{workspacename}`
(`API.workspaceByOwnerAndName`), matching the get-workspace-by-ID
endpoint.
- Parses `include_related` via `wsrelated.Parse`; absent defaults to
`wsrelated.All()`, present-but-invalid returns 400.
- Passes the parsed config to `singleWorkspaceData`, preserving template
concealment (unauthorized template maps to 404 on this route).
- Omitted related data (build/template) is converted from zero values;
the build-not-found 404 only applies when the build was requested.
- Adds `TestWorkspaceByOwnerAndNameIncludeRelated` covering full,
template-only, latest-build-only, and invalid selections.
- Regenerated API docs/swagger.
_This PR was created by Coder Agents on behalf of @spikecurtis._
|
||
|
|
756ffb97af |
feat: add a collapse_assistant_steps user preference (#29416)
## Stack context Bottom of a six-PR stack that adds the **Collapse assistant steps** chat preference (Agents > Settings, off by default). With it on, each turn's consecutive tool-step rows fold into one disclosure: "Worked for 2m 14s (7 steps)" once the turn completes, or a ticking "Working for 12s" while it runs. The stack was split out of #29115 for review size; #29115 now sits at the top with the full feature description and the UAT record. 1. #29416 feat: add a collapse_assistant_steps user preference (this PR) 2. #29417 feat(site): group assistant steps into working blocks 3. #29418 feat(site): add the working block disclosure 4. #29419 feat(site): fold assistant steps in the conversation timeline 5. #29420 fix(site): keep streaming text alive inside expanded working blocks 6. #29115 feat(site): add the collapse assistant steps chat preference ## Why The chat UI reads a per-user boolean to decide whether to fold steps. This layer stores it and exposes it through the preference settings API and SDK. `collapse_assistant_steps` follows the existing `task_notification_alert_dismissed` boolean pattern: a `user_configs` key with dbauthz wrappers, no migration. The generated API docs and TypeScript types are regenerated, and the frontend preference mocks gain the new required field. > This PR was prepared by Xum, an AI coding agent, on behalf of @ibetitsmike. |
||
|
|
0eed5465f2 |
feat: allow creating chats without an initial message (#27111)
> Written by Mux on behalf of Mike.
## What
`POST /api/v2/chats` now accepts an empty `content` array. The chat is
created idle (`waiting`) with system messages only: no user message is
inserted, no ownership hint is published, and no chat worker picks it
up. Generation starts when the first message is POSTed to
`/chats/{chat}/messages`.
## Why
The new-chat page needs to upload files into the chat's workspace before
the first turn, and `POST /chats/{chat}/workspace-files` requires a chat
ID. There was previously no way to sequence "create chat, upload files,
send first message": creation required non-empty content and started
generation immediately. This PR adds the enabling primitive; the UI
lands in the next PR of the stack.
## How
- `chatstate.CreateChat` takes an explicit `InitialStatus` (`waiting` or
`running`, validated). The existing `IsRunnable()` gate keeps ownership
hints suppressed for `waiting` chats.
- `chatd.CreateChat` derives the status from `InitialUserContent`: empty
content means `waiting` with system messages only, and `APIKeyID` is
only required when a user message is inserted.
- `createChatInputFromRequest` returns empty blocks for empty content
instead of rejecting; the `/messages` path still rejects empty sends.
- Chats created this way carry the `New Chat` placeholder title. Title
generation now treats that placeholder as replaceable. When the first
message lands on such a chat, `chatd.SendMessage` detects the first user
turn inside its transaction (under the chat row lock), writes the
fallback title in the same transaction, and reports `FirstUserTurn`;
`postChatMessages` then fires `GenerateChatTitleForMessagesAsync` to
upgrade it. A failed title call therefore still leaves a meaningful
title.
- `ARCHITECTURE.md` carries `TODO (#27111)` items in the transition list
and the `POST /api/v2/chats` section for the new `N -> Create -> W`
transition (the doc text and the diagram edge are left for the author
per the chatd guardrail).
## Follow-ups
- Automatic title generation (both the create path and the first-message
path added here) writes the generated title unconditionally, so a user
rename that lands while the title model call is in flight is
overwritten; a compare-and-set title update would close that
pre-existing window.
- `chats.last_reasoning_effort` is derived from inserted messages, so an
idle chat created with `reasoning_effort` does not persist it until its
first message; the first message applies the owner's personal
reasoning-effort override (when it targets the same model) if the
request omits an effort, matching `POST /chats` with content.
## Testing
- chatstate: `N -> W` lands in `StateW` with no ownership hint; invalid
initial statuses are rejected.
- chatd: empty create produces a `waiting` chat with system messages
only.
- HTTP: empty create + first message (`W -> R0`, inserts directly, not
queued), immediate archive of an idle chat, workspace file upload
against an empty-created chat, and title generation on the first
message.
|
||
|
|
5dde49dffb |
feat: add chat workspace file upload endpoint (#27079)
## What
Adds `POST /api/v2/chats/{chat}/workspace-files`, which streams the
request body to the chat's bound workspace agent and returns the final
path/name/size, plus the `workspace-file-reference` message part type
that carries the uploaded file's metadata through chat messages:
- `coderd/exp_chats.go`: owner-only middleware (chat RBAC update +
reject archived), workspace exec authorization (403/409 like the
existing chat exec paths), agent selection (prefer the chat's bound
agent, else deterministic `agentselect.FindChatAgent`, without
persisting a binding), 30s dial timeout, chat/ancestor tracking headers
on the agent connection, and agent error passthrough (agent HTTP status
preserved, 502 with a generic detail for transport failures; the real
error is logged). Deleted and non-running workspaces get a specific 409
("Workspace is stopped. Start the workspace before uploading files.")
before agent lookup. Each failed upload logs one structured warning, and
`coderd_chat_workspace_upload_total{status}` counts outcomes. The route
shares the files rate limit and documents its 429.
- Input validation: client-supplied `workspace-file-reference` parts
must point inside `/.coder/chats/<chat-id>/files/` with a matching
basename, non-negative size, and a `workspace_file_workspace_id` equal
to the chat's currently bound workspace (the upload response echoes it
as `workspace_id`). References uploaded before a workspace rebind are
rejected instead of silently sending the agent an unreadable path. The
file name must already be in sanitized form
(`SanitizeWorkspaceUploadName(name) == name`), and the cleaned path and
base media type are what gets persisted; message edits share the same
validation. Parts are rejected on chat creation (no chat ID exists yet).
- `coderd/x/chatd/chatprompt`: references render into the prompt as text
only, `[workspace file: <name> (<size>) at <path>]`; file bytes never
reach the LLM. Title derivation (`TitleText`) uses the bare file name,
so fallback titles carry no internal marker.
- `codersdk`: part-type constants/fields,
`ChatMessageWorkspaceFileReference` builder, and
`Client.UploadChatWorkspaceFile` (RFC 5987 filename in
`Content-Disposition`).
No DB migration: parts persist as JSON in `chat_messages.content`.
## Why
Bridges chat and the workspace filesystem for CODAGT-211: users drop a
file in chat, the bytes land where the agent's tools can operate on
them, and the model learns the path from the reference part.
## How tested
- `go test ./coderd -run 'WorkspaceFile|ChatInput|UploadChat'` including
an integration test that runs a real in-memory agent, uploads through
the coderd route, verifies bytes on disk, and exercises collision
suffixes.
- `go test ./codersdk ./coderd/x/chatd/...`, `make gen`
(swagger/types/docs), `make lint`.
- Rebased onto main 2026-09-21: the chat API moved from
`/api/experimental` to `/api/v2`, so the route is registered in
`coderd/chat_routes.go` and the SDK method lives on `codersdk.Client`.
## Follow-ups
- The files rate limit counts requests, not bytes or concurrency;
whether this route should use a per-user concurrency cap instead, and
whether the new-chat page should keep partial successes on a 429, is
still open
([CODAGT-1171](https://linear.app/codercom/issue/CODAGT-1171)).
Part of CODAGT-211. Stack: agent API -> coderd endpoint (this PR) -> UI.
> This PR was authored by Mux (AI) working on Mike's behalf.
|
||
|
|
282365b23a | feat: report clicks on the workspace build debug action to telemetry (#29853) | ||
|
|
46ccaf3764 |
chore: mark organization AI spend users endpoint as experimental (#29842)
## Description
Move `GET /organizations/{organization}/ai/spend/users` under
`/api/experimental` so the per-user spend report is not part of the
stable API for this release. The endpoint behavior is unchanged.
Related to [internal Slack
thread](https://codercom.slack.com/archives/C04M9CNGHGF/p1790190171687059?thread_ts=1790190121.005749&cid=C04M9CNGHGF).
## Changes
- Register the route on the experimental handler and mark it
`@x-apidocgen {"skip": true}`, which removes it from the generated API
reference.
- Move the Go SDK method to `ExperimentalClient` and the frontend method
to `API.experimental`.
- Drop the docs link to the removed API reference section. The link is
commented out with a TODO so it can be restored later.
User-facing docs for the **User spend** page are updated upstack in
#29844.
> [!NOTE]
> Generated by Coder Agents on behalf of @ssncferreira.
|
||
|
|
702b13112d | feat: add Debug with Coder Agents action for failed workspace builds (#29811) | ||
|
|
f64ccfb836 |
feat: add experimental inline MCP servers (#29546)
Closes CODAGT-1131 Fifth PR in the inline MCP servers stack, on top of #29520. A chat owner can now declare MCP servers by URL and headers on their own chat, and chatd connects to them every turn alongside the org-configured ones. They go in a new `inline_mcp_servers` field on `POST /api/v2/chats` and `POST /api/v2/chats/{chat}/messages`, which replaces the whole set (omit to keep, `[]` to remove). Root chats only. `GET /api/v2/chats/{chat}` returns them, with the URL blanked for non-owners and header values never returned. Subagents only get servers marked `allow_in_subagents`, a root chat in explore mode gets none, and a root chat in plan mode gets all of them. URLs must be `https`, or `http` to an IP literal in `CODER_MCP_ALLOWED_PRIVATE_CIDRS`. Header values have no minimum length, so anything under the redactor's 8 byte floor from #29518 is accepted but not redacted, which the docs call out. Every cap is exported from `codersdk`. It's behind the `chat-inline-mcp-servers` experiment, and the `--disable-chat-caller-supplied-tools` kill switch from #29466 covers it too. With either off, declaring servers gets a 403 and existing chats stop connecting to theirs, but `[]` still works so a client can detach. Load failures show up in the chat debug panel as failed connections, as do org servers with an invalid config. Docs are hand-written in `mcp-servers.md`. |
||
|
|
c1af0793e5 |
feat: add caller-supplied tools kill switch for chats (#29466)
This is the first PR in a stack that adds experimental support for attaching MCP servers to a chat when it's created, and then deprecates `unsafe_dynamic_tools` in favour of them. Both are "caller-supplied tools", i.e. tools the client hands to coderd at chat creation rather than tools an admin has configured, so we want a single switch admins can use to turn all of them off. This PR adds that switch: `--disable-chat-caller-supplied-tools` (`CODER_DISABLE_CHAT_CALLER_SUPPLIED_TOOLS`). It follows the existing `disable-*` deployment flag pattern (`--disable-chat-sharing` etc.), so there's no new API route and it's independent of any experiment. When set, `POST /api/v2/chats` returns a `403` if the request includes `unsafe_dynamic_tools`, and chats that already have dynamic tools run without them; a call to one gets a tool error result and the model just continues. Later in the stack, chat-attached MCP servers are gated behind the same flag. It's unset by default, so nothing changes unless you opt in. Part of CODAGT-1131 |
||
|
|
2de1f8b111 |
feat: link promoted chat messages to their queue entry (#29859)
Signed-off-by: Thomas Kosiewski <tk@coder.com> |
||
|
|
5393f9d5f4 |
feat: stream advisor reasoning in tool cards (#29742)
Show the advisor’s live reasoning under **Thinking**, separately from **Advice**, in one tool card with the original question and title. Keep nested reasoning out of the parent assistant’s reasoning and saved chat history. Clear both live channels on retry and remove transient reasoning when the call finishes. Cover streaming, retry, error, and interrupted-output behavior with regression tests, and regenerate the SDK and API schemas. This also changes a shared seam for every tool, not only the advisor: live output for a tool call that is already saved now completes that call's card, and the separate live-row card for it is removed. Remote UAT passed on `a39bbe4c21`: deterministic provider tests covered streamed reasoning, retry, errors, and refresh; a real-provider run confirmed advice streaming and card association. The real model did not emit reasoning. The intermittent, unattributed React console warning is tracked in #29741. <details> <summary>Remote UAT evidence (deterministic provider)</summary>  Streaming, completion, and refresh: https://github.com/user-attachments/assets/dd1f3a24-a365-40c8-a1d9-b78cd17ef4c5 </details> --- <details> <summary>📋 Implementation Plan</summary> # Plan: Stream advisor reasoning in Coder Agents ## Goal and delivery boundary Show nested advisor reasoning as live **Thinking** in its advisor tool card. Keep it separate from live **Advice**, normal parent-assistant reasoning, and the final persisted advisor result. Deliver one focused PR: optional SDK field, nested publisher, transient frontend state, existing card rendering, generated API artifacts, and regression tests. Do not add provider features, persistence, new stream event types, UI redesigns, or unrelated cleanup. The implementation already exists and has been reconciled with current main. The implement-flow implementation phase is an acceptance audit, not a rewrite. Preserve correct behavior and current architecture. Change only demonstrated gaps. A no-op implementation result is valid; do not manufacture an empty commit. ## Current integration points 1. `codersdk/chats.go`: add optional `ReasoningDelta string` with `json:"reasoning_delta,omitempty" variants:"tool-result?"`. Preserve it in `StripInternal` alongside other live fields. Register the same NUL-encoding policy as `ResultDelta` in `chatprompt` so the SDK field coverage and round-trip tests remain complete. Regenerate SDK types and API documentation with `make gen`. 2. `coderd/x/chatd/chatadvisor/runner.go`: route assistant text and reasoning through separate optional callbacks on `RunAdvisorOptions`. Install the publisher if either callback exists. Preserve empty-delta and role guards. Use current `GenerateAssistant` and `chatretry.Retry`. Rename the reset callback to `OnLiveOutputReset` because it clears advice and reasoning. Keep `extractAdvisorText` text-only and existing budget/refund behavior. 3. `coderd/x/chatd/chatadvisor/tool.go`: use the current context-injected `MessagePartPublisherFromContext`; do not reintroduce the old ToolOptions publishing callbacks or chatd.go wiring. Preserve the missing-publisher error and the nonempty tool-call-ID guard. Publish reasoning as role `tool`, part type `tool-result`, tool name `advisor`, matching `tool_call_id`, and `reasoning_delta`. Use existing `result_reset` to reset both live channels on retry. 4. `site/src/pages/AgentsPage/components/ChatConversation/streamState.ts` and `types.ts`: retain a single transient reasoning string. Append deltas exactly as plain text, never JSON-parse or trim them during accumulation. Reasoning makes the tool streaming. An empty `result_delta` must not swallow a nonempty `reasoning_delta`. Reset removes the entry. A final result or `is_error` clears reasoning and streaming state. Pass reasoning through `buildStreamTools` into `MergedTool`. 5. `MessageBlocks.tsx` and `ChatElements/tools/Tool.tsx`: forward reasoning at both current Tool instantiation paths and through AdvisorRenderer. Do not restore the old ConversationTimeline rendering implementation. 6. `AdvisorTool.tsx`: use current `ToolCall.Root`, `ScrollArea`, `Response`, and semantic theme tokens. Display Thinking only when running and trimmed reasoning is nonempty. Display live advice separately when present. Keep completed advice, empty/loading, limit, and error behavior unchanged. Reasoning-only running cards must not show the empty-advice fallback. Do not restore removed MUI dependencies. 7. `messageParsing.ts`, `streamState.ts`, and `ChatPageContent.tsx`: associate live tool results with matching durable tool calls. Preserve the invocation's question, intent, and metadata. A durable final result remains authoritative, including explicit null results. Remove only the overlaid result and its block from the separate live row; keep unrelated results and live call/result pairs unchanged. This closes the durable-call/live-result split found during integration testing. ## Acceptance criteria 1. Nested reasoning reaches the dedicated runner callback and the client as tool-scoped live output for the same advisor call as advice. 2. Advisor reasoning is not parent assistant reasoning, final advice, input to the parent's continuation, or persisted chat history. 3. Retry clears stale reasoning and advice before fresh output. Final success and bare error clear transient reasoning. 4. Raw whitespace and JSON-looking reasoning survive concatenation unchanged. Empty advice deltas do not hide reasoning. 5. Reasoning-only and reasoning-plus-advice states render in exactly one existing advisor card per invocation, retaining its question and intent title when the call is already durable. Completed cards never display transient thinking, even if handed a stale prop. Other tool and normal assistant reasoning behavior is unchanged. 6. Generated artifacts match source. Final candidate passes relevant Go tests, frontend tests, stories, typecheck, lint, and pre-commit checks, or has explicit verified blockers. Old evidence is not final-candidate evidence. ## Phases and quality gates 1. Reconcile existing work onto current main while retaining a recovery snapshot. Remove obsolete workarounds, not current upstream behavior. Gate: no conflicts, focused diff, preserved original work. 2. Audit regressions at the existing runner, tool publisher, parent-chat stream, and frontend state boundaries. Add one missing behavior at a time. Reproduce failures before fixes. Gate: failing tests demonstrate the defect and pass after the smallest fix. 3. Simplify only within this feature. Use one reasoning string and existing publishers/components. Gate: tests remain green, generated diff is scoped, FE1 through FE10 pass. 4. Commit the candidate with repository hooks enabled, then run the packaged implement-flow audit, validation, remote UAT, and polish stages. Gate: readyForPr and verified remote evidence for the exact final candidate. If polish changes HEAD, refresh the UAT evidence for that SHA. 5. Create a reviewable PR and complete green CI plus bounded Codex review on its exact head. Get one fresh independent readiness recommendation. Gate: no unresolved review threads, required evidence recorded, and a justified readiness decision. Do not merge. ## Regression coverage - Runner: reasoning and advice callbacks remain separate; final advice and usage count stay correct. Retain existing retry/refund tests. - Tool: all reasoning/advice events carry role tool, type tool-result, advisor name, and the invocation ID. Without an ID, emit no live output. Retry emits stale reasoning/advice, reset, then fresh reasoning/advice. - Chatd: extend `TestAdvisorHappyPath_RootChat` with deterministic `openai-compat` reasoning chunks. Hold the nested response until the live subscriber captures expected reasoning and advice. Observe the complete relevant event set, assert no parent-assistant reasoning, and check continuation and persisted content contain no advisor reasoning. Extend only the test fixture needed to emit `reasoning_content`; do not change production adapters. - Frontend: extend streamState tests for exact accumulation, whitespace, JSON-looking text, reasoning-only streaming, empty advice delta, reset, final result, and bare error. - Durable/live integration: replay a durable assistant tool call followed by live reasoning and advice results. Assert the durable card receives both channels and the live row no longer owns the same result or block. Preserve unrelated IDs and live calls. Clear the overlay on reset; prefer durable final results, including null. Cover the complete display path with a real-store ChatPageContent story. - Visual stories: running reasoning-only, running reasoning-plus-advice, and completed with stale reasoning. Keep existing limit/error stories. Stories set up visual states without assertions, following current FE1. ## Validation Run targeted checks while iterating, then the broader gates: ```sh umask 022 go test ./coderd/x/chatd/chatadvisor ./coderd/x/chatd ./codersdk -run 'Advisor|ChatMessagePart|ChatStream' -count=1 pnpm -C site exec vitest run --project=unit src/pages/AgentsPage/components/ChatConversation/streamState.test.ts pnpm -C site exec vitest run --project=storybook src/pages/AgentsPage/components/ChatElements/tools/AdvisorTool.stories.tsx make gen make fmt make test RUN='Advisor|ChatMessagePart|ChatStream' pnpm -C site lint:types pnpm -C site check pnpm -C site lint make lint make pre-commit ``` Keep native exit codes and logs. Do not hide a failed check, bypass hooks, or fix unrelated baseline problems in this PR. Stage intentional generated/formatting changes before pre-commit's clean-diff checks. Report exact blockers and risks. ## Remote dogfood UAT Use the coder-agents-uat skill and an independent critical Coder Agent, not a local-only substitute. Push only the named feature branch. Test its exact SHA in an isolated workspace/deployment without changing shared model credentials or configuration. Use an isolated user, chat, and model config. Setup: 1. Read the branch diff and UAT scope. Record the branch and SHA. 2. Start Coder with the repository-supported `./scripts/develop.sh --port-offset` (or `CODER_DEV_PORT_OFFSET=true`). Do not replace it with a manual server launch. Record effective API/UI URLs and wait for readiness. 3. Prefer a deterministic mock OpenAI-compatible provider that emits advisor reasoning and advice separately, and a retry after stale output. Use only isolated configuration. Never print or capture secrets. 4. Start a named agent-browser session. Attempt `agent-browser skills get core`; record the installed version/fallback if unavailable. Record video before the scenario, then install any stream capture since recording may recreate browser context. Scenario: 1. Create a normal advisor-enabled root chat. Do not use Plan Mode: current product behavior excludes the advisor there. 2. Capture the initial state. Prompt the parent to call advisor. 3. While the tool is running, capture reasoning-only and reasoning-plus-advice states. Verify exactly one advisor card per tool-call ID, with its original question and intent title. Verify Thinking and Advice stay separate inside that card and the parent thinking area does not receive nested reasoning. 4. Capture the relevant WebSocket event set. Verify role tool, type tool-result, advisor name, matching tool-call ID, and reasoning_delta. An advisor-filtered subset is insufficient to prove absence of parent reasoning. 5. Let the advisor finish. Verify final advice remains, Thinking disappears, and refresh does not restore transient reasoning. 6. Exercise retry with the deterministic provider if feasible. Verify stale reasoning/advice clears before fresh output. If not exercised, record the omission and remaining test evidence; do not claim it was dogfooded. 7. Capture console errors before and after. Inspect the screenshots and semantic video frames, not only successful media decoding. Required evidence: exact tested SHA; remote chat URL; setup command and effective URLs; non-secret provider/model names; before/thinking/thinking-plus-advice/completed screenshots; a short streaming video; complete relevant stream evidence; refresh and retry observations; console results; explicit omissions; and owned-resource cleanup receipts. Keep evidence under `.mux-uat/round-<n>/`, excluded from source commits. When publishing evidence to GitHub, use native `gh --attach`, not cookie-based uploads or gh-image. Cleanup: stop only owned develop/provider processes and named browser sessions. Do not use unscoped process sweeps, shared database resets, or `agent-browser close --all`. </details> --- _Generated with [`xum`](https://github.com/coder/xum) • Model: `coder:openai/gpt-6-astra` • Thinking: `xhigh`_ --------- Signed-off-by: Thomas Kosiewski <tk@coder.com> |
||
|
|
c95a87cea7 |
feat: warn before narrowing a self-registered OAuth2 app's scope allowlist (#29777)
- Warn rather than block when admins narrow a self-registered OAuth2 app's scope allowlist. Clients requesting all advertised scopes may receive `invalid_scope` on new authorizations; existing tokens retain their scopes. - Expose `dynamically_registered` in API responses and display registration type on the app page. - Show no warning for widening or clearing allowlists, or for admin-created apps. - Update scope and `invalid_scope` troubleshooting docs and remove the outdated note that the UI cannot set allowlists. Closes PLAT-664. |
||
|
|
bacb4fc6ed |
feat: expose per-app session counts (#29351)
Track individual applications across deployment statistics, Prometheus, telemetry, and the dashboard instead of exposing only fixed family totals. Preserve existing fields and gauges so current consumers can migrate without breaking. - Add per-app counts with normalized identifiers and registry-backed display names, families, and bundled icons. Unrecognized apps retain their identifiers. - Limit each statistics report to 64 distinct app names, combining excess names into an explicit overflow bucket. - Group dashboard connections by family, including an Other category, with alphabetical per-app tooltips and distinct loading and empty states. - Export app-keyed Prometheus counts separately from current family metadata, allowing queries to enrich historical counts without rewriting stored samples. - Document family queries with unknown fallback, deployment isolation, and replica handling, alongside collection behavior and migration guidance. - Include per-app counts in telemetry, update API schemas and documentation, and add regression coverage across collection, metrics, and dashboard behavior. Closes #27411 |
||
|
|
528dd3cc44 |
feat: edit an OAuth2 app's redirect URIs as an ordered list (#29603)
Completes PLAT-619, following #29440 and #29502. - Replace the OAuth2 app’s single callback field with an editable `redirect_uris` list supporting 1–32 entries, with the first labeled “Default callback.” - Show a `+N` badge for additional redirect URIs in the applications table. - Remove `omitempty` from request `redirect_uris` so explicit empty lists reach the server. - Add tests and stories for adding, editing, removing, and requiring at least one URI. |
||
|
|
395e8032dc |
fix: reject client_secret in the OAuth2 token and revocation URL (#29508)
Reject non-empty `client_secret` query parameters on token and revocation endpoints with `400 invalid_request`, enforcing OAuth 2.1 §2.4.1 (D6-04). - **Breaking:** Send secrets in the request body or `Authorization` header, and rotate any previously sent in URLs. Rejections consume nothing, so clients can retry without reauthorization. - Empty query secrets count as absent, but token requests also supplying a body secret still fail duplicate-parameter validation. Authorize ignores query secrets and logs a warning without the value. - Sanitize and cap revocation parse errors, correctly report repeated token parameters, and update tests and API docs. Refusal logs include the app ID, never the secret. - Other query parameters (`client_id`, `refresh_token`, `code`, and revocation tokens) remain accepted; body-only credential parsing is tracked in PLAT-660. No migration or new error codes. Refs PLAT-602. |
||
|
|
5e41baf73c |
docs: normalize control plane, coderd, and coder server terminology (#28960)
Normalizes the three overlapping names for the thing that serves the Coder API and dashboard. This is step 1 of the Install/Deploy and Administration refactor ([DOCS-685](https://linear.app/codercom/issue/DOCS-685), [DOCS-738](https://linear.app/codercom/issue/DOCS-738)) and lands first because every later page depends on settled terminology. Resolves [DOCS-871](https://linear.app/codercom/issue/DOCS-871). ## The rule | Term | Means | Use when | |---|---|---| | control plane | The component that serves the Coder API and dashboard, brokers connections, and coordinates provisioners | Default in prose, diagrams, planning, sizing, security | | `coderd` | The process that implements it | Architecture internals, metrics, logs, flags, troubleshooting | | `coder server` | The literal CLI command | Only when the reader will type it | Retired: "the Coder server" as a name for the component, and "a service" as a standalone description of it. ## What changed - **`docs/.style/style-guide/word-choice.md`**: new "Naming Coder's components" rule, with do/don't examples. Also fixes a "Do" example on that page that itself used "the Coder server". - **`docs/reference/glossary.md`**: rewrote `coderd` and Control plane, added a `coder server` entry. The existing Control plane entry defined it as "the collective term for `coderd`, its provisioners, and its database", which made it indistinguishable from the Deployment entry two sections later. Control plane is now the component; Deployment remains the whole installation. - **65 pages** across `docs/admin`, `docs/install`, `docs/get-started`, `docs/tutorials`, `docs/user-guides`, `docs/ai-coder`, and `docs/about`: roughly 154 component-sense "Coder server" usages, 21 bare "the server" usages meaning the control plane, 3 "a service" descriptions, and 43 unbackticked `coderd` mentions in prose. - One real bug caught in passing: `docs/tutorials/best-practices/security-best-practices.md` documented `coderd server --disable-path-apps`, which is not a command. Now `coder server`. Generated files were not touched: `configuration-reference.md`, `prometheus.md`, `audit-logs.md`, `reference/cli/*`, `reference/api/*`, and the generated blocks inside `feature-stages.md`. Those still contain the retired term and need generator-side changes; see the deferred list below. ## Reviewer attention, please **Anchor changes.** 11 headings were renamed, so their fragments change. No in-repo link targets any of them (the one internal link that did was updated), but external deep links from tickets or blog posts would break, and fragments cannot be fixed with a redirect. Happy to revert any of these if you would rather they ride along with the page moves in [DOCS-869](https://linear.app/codercom/issue/DOCS-869), which changes those URLs anyway. <details> <summary>Renamed headings and their old fragments</summary> | File | Old fragment | New heading | |---|---|---| | `admin/networking/index.md` | `#coder-server` | `## Control plane` | | `install/index.md` | `#starting-the-coder-server` | `## Starting the control plane` | | `install/uninstall.md` | `#the-coder-server-binary-and-cli` | `## The Coder binary and CLI` | | `install/registry-mirror-artifactory.md` | `#step-5-configure-coder-server-or-provisioners` | `## Step 5: Configure the control plane or provisioners` | | `install/cloud/compute-engine.md` | `#configuring-coder-server` | `## Configuring the control plane` | | `get-started/index.md` | `#cant-start-coder-server-address-already-in-use` | ``### Can't start `coder server`: Address already in use`` | | `tutorials/external-database.md` | `#coder-server-fails-startup-with-...` | ``### `coder server` fails startup with ...`` | | `tutorials/faqs.md` | `#how-do-i-change-the-access-url-for-my-coder-server` | `## How do I change the access URL for my control plane?` | | `tutorials/best-practices/security-best-practices.md` | `#coder-server` | `## Control plane` | | `tutorials/best-practices/security-best-practices.md` | `#server-logs-and-audit-logs` | `### Control plane logs and audit logs` | | `tutorials/best-practices/scale-coder.md` | `#coder-server`, `#how-to-capture-coder-server-metrics-with-prometheus` | `## Control plane`, `### How to capture control plane metrics with Prometheus` | </details> **One deliberate deviation from the issue.** DOCS-871 proposed reserving "sub-agent" for the Coder Agents sense and using "devcontainer agent" for the workspace sense. I did not make that change. The glossary already disambiguates with "Sub-agent (Coder Agents)" and "Sub-agent (dev containers)", and "devcontainer agent" would violate the existing dev container spelling rule in the same style guide, which requires "dev container" as two lowercase words. The current split reads correctly and costs no churn. Happy to revisit if you disagree. <details> <summary>Deferred, with reasons</summary> - **Generated content still says "Coder server".** `reference/cli/*` comes from Go command help text, `configuration-reference.md` from `configdocgen`, and `reference/api/*` from Swagger annotations. Fixing those means changing Go source, which belongs in its own PR so a docs review does not turn into a backend review. - **`validated-architectures/index.md` "also known as `coderd`"** is fixed here, but the page's larger problem is that it holds four documents in one file. That split is [DOCS-868](https://linear.app/codercom/issue/DOCS-868). - **"server flag" phrasing** in `admin/users/idp-sync.md` and `admin/users/oidc-auth/index.md` means `coder server` flags. Left alone; rewording those sentences is a copy edit, not a substitution. - **Metric and UI labels** such as "Dashboard-to-server latency" in `admin/networking/index.md`. Renaming risks diverging from what the dashboard shows. - **Pre-existing `Coder.GerundHeading` warnings** on headings this PR touches, and a "from from" typo in `scale-coder.md`. Out of scope for a terminology pass. - **Peer-sense "server"** in NAT traversal prose, where "client or server" describes the connection roles rather than the control plane. Needs restructuring, not substitution. </details> ## Verification | Check | Result | |---|---| | `make lint/emdash` | pass | | `make lint/markdown` | pass, 504 files, 0 errors | | `make lint/docs-html` | pass | | `make lint/prose` | pass, findings identical to the `main` baseline (1 intentional demo error, 145 warnings, 1 suggestion; only Vale's file ordering and one line-number shift in `glossary.md` differ) | | `make gen` | clean, no drift | | `make fmt/markdown` | applied | No redirects needed: no page moved or was renamed in this PR. <details> <summary>Merged main, 2026-09-14</summary> One conflict, in `docs/ai-coder/ai-gateway/providers.md`. Both hunks were text this PR had edited and `main` had since deleted in #29053, which removed env-based AI provider configuration: - The deprecated provider seeding note, which held a `coderd` backtick fix, is gone. Took `main`. - The failure-mode table lost its env-drift row. Took `main`'s two rows and reapplied the `coderd` logs wording. `main` also landed new prose carrying the retired terms, so the pass was extended to cover it: - `docs/admin/integrations/oauth2-provider.md`: two "the server log(s)" in the scope-enforcement sections added by #29144 are now "the `coderd` log(s)"; "a `scope` the server will not grant" is now "the control plane". - `docs/reference/cli/index.md` gained "the server" from #29104, and stays deferred as generated content. The new `docs/ai-coder/agent-relay/claude-code.md` needed no change, and no page `main` added links to a heading this PR renamed. </details> <details> <summary>Decision log for the wider refactor</summary> Agreed with @nickvigilante before implementation, recorded on DOCS-685 and in the Notion outline: 1. Feature stages and release channels move to Reference; ESR upgrade guides move under Operate. No new top-level Releases section. 2. `data-retention.md` moves to Administration > Security; `chat-lifecycle-hooks.md` moves into the Coder Agents docs. `admin/setup/` therefore survives as "Deployment configuration" and `configdocgen` is not touched. 3. Prepare is advisory, not a gate, framed as "don't know where to start? Start here", with lead times and owners per item. 4. One actor table, on the Install overview, spanning all five phases, noting that one person can be several actors and several people can be one actor. 5. The quickstart stays independent and is mentioned once, on the Install overview. The proposed `server/single-machine` page is dropped. 6. Coder Validated Architecture keeps its name in nav, defined in-page, with a glossary entry. 7. PR 3 is split: moves only, then prose, so the riskiest change reads as a pure rename diff. 8. For every PR that moves a page, the coder.com `redirects.json` change merges first. 9. There is no Download section and no CLI page in docs. Per-OS CLI steps live on coder.com/download and the Install overview links to it. </details> Generated with Coder Agents on behalf of @nickvigilante. |
||
|
|
9fd0131d04 |
feat: accept redirect_uris on the OAuth2 app admin API and deprecate callback_url (#29502)
- Add `redirect_uris` to admin OAuth2 app responses and create/update requests. - Deprecate `callback_url` while preserving compatibility; it maps to the first redirect URI. - Reject empty `redirect_uris` lists instead of silently ignoring them. - Update fixtures, tests, and docs. Part of PLAT-619. Builds on #29440; admin UI support follows in #29603. |
||
|
|
80eee58d1d |
feat: add the organization AI spend client method and report fixture (#29627)
Adds `API.getOrganizationAISpendUsers(organizationId, params)` for `GET
/api/v2/organizations/{organization}/ai/spend/users` (period, provider,
model, client filters plus `limit`/`offset`), the
`MockOrganizationAISpendReport` fixture, and a shared
`codersdk.MaxAISpendPeriodDays` constant that the enterprise export
handler now reads and that `make gen` emits into `typesGenerated.ts`.
The model-list endpoint also accepts a literal `model` prefix. The
backend escapes SQL LIKE characters, while `q` keeps its existing search
syntax. Supplying both nonempty parameters returns 400. The filter menu
adopts this parameter in #29632.
## Why
The frontend caps custom ranges at the same 31-day limit the server
enforces; one SDK constant keeps the two from drifting. The fixture is
what every later test and story renders. Literal model identifiers
should not require search-language quoting or SQL escaping in the
frontend.
## What to scrutinize
- `enterprise/coderd/aibridge.go`: `maxAISpendExportPeriod` is now
derived from the SDK constant, same value as before.
- `MockOrganizationAISpendUser` is not exported yet; the table PR
exports it for its stories (knip fails on exports without a consumer).
## Generated files
`site/src/api/typesGenerated.ts`, `coderd/apidoc/docs.go`,
`coderd/apidoc/swagger.json`, and `docs/reference/api/aigateway.md` via
`make gen`.
## Validation
`pnpm test src/api/api.test.ts -t getOrganizationAISpendUsers` (new
case), `go test ./enterprise/coderd/ -run TestAIBridgeListModels
-count=1 -v`, repository pre-commit including `make gen` with no drift.
Model tests cover literal punctuation, prefix matching, existing `q`
behavior, and conflicting parameters.
## Delivery record
Published head `8d9a4faa0aa` passed per-layer integration checks and
commit hooks. The composed head `d899228f798` passed format, check, full
frontend lint, 125 unit tests, and 86 story tests. Pre-push hooks were
skipped as requested. See #28964 for audit findings, their disposition,
and historical UAT limits. No exact-head live UAT or new independent
re-review is claimed.
## Stack context
PR 3 of 9. The stack adds a **User spend** page under **Admin settings**
> **AI** > **User spend**: total and per-user AI Gateway spend for one
organization over a reporting period, read from `GET
/api/v2/organizations/{organization}/ai/spend/users` (#29129, merged).
It is #28964 split into one-concern PRs. Historical UAT covers earlier
heads only; live UAT has not been rerun after these review fixes. Bottom
to top: DateRangePicker limits, shared dimension badge, API client
method, spend table, page view, page container, reporting period,
dimension filters, route and navigation (#28964).
> Xum prepared this PR on behalf of @ibetitsmike.
|
||
|
|
60cc826f2b | feat: sign forwarded MCP identity headers (#29669) | ||
|
|
af0ef00f91 |
feat: add owner_id to CreateChatRequest to create chats for another user (#29581)
Owners and owner-level service accounts can now start a Coder Agents
chat on behalf of another user by setting `owner_id` on `POST
/api/v2/chats`. The field is optional and defaults to the caller, so
existing clients are unaffected. A delegated owner must be an active,
non-system member of the requested organization; anything else returns
400 `Chat owner must be an active member of the organization.` once the
caller has passed the authorization gates below.
A chat runs entirely with its owner's credentials (synthetic API key,
workspace access, OIDC and provider tokens), so creating one for someone
else is acting as that user. On top of org-scoped `chat:create` for the
owner, the caller must hold the authority to create API keys for that
user, which is what the token endpoint demands to mint their session.
Org admins therefore cannot use it; site owners and owner-role service
accounts can. For the same reason the workspace binding, model config,
and MCP server IDs are validated as the owner rather than the caller,
and the owner must themselves hold `chat:create` (organization service
accounts do not). The initial user message is attributed to the caller
through `chatd.CreateOptions.CreatedBy`.
An earlier revision of this PR exposed the same behavior as `POST
/api/v2/users/{user}/chats`; that route and
`codersdk.Client.CreateUserChat` were removed in `62a8be3dd32` in favor
of the request field. An explicit zero `owner_id` is rejected with 400
rather than silently defaulting to the caller. Coverage lives in
`TestPostChats_OwnerID`.
<details>
<summary>Review record (path-based revision, gates unchanged)</summary>
- Two-axis code review (Standards, Spec) plus a simplicity audit ran as
Xum sub-agents on `1f3189898f0`. The Spec axis found the workspace
binding was authorized as the caller, fixed in `363d45281d8` with
red-green coverage in `WorkspaceNotAccessibleToOwner`. The additional
API-key gate and the `CreatedBy` attribution go beyond the workspaces
pattern and were kept deliberately for the reasons above.
- Codex review on `363d45281d8`: one P2, suspended, dormant, or system
users could be targeted and would get a chat that can never run because
AI Bridge refuses to authorize them. Fixed in `c065437e359` with
`OwnerSuspended` (red on the old head); thread replied to and resolved.
- Codex review on `c065437e359`: one P2, an explicit or
personal-override model config the caller can read but the owner cannot
was accepted and chatd would silently fall back to the default model at
run time. Fixed in `aa88b608182` by resolving the model config and MCP
server IDs under the owner's context, with
`ModelConfigNotAccessibleToOwner` (red on the old head); thread replied
to and resolved.
- Codex review on `aa88b608182`: one P2, an organization service account
(which deliberately holds no chat permissions) could be targeted because
the chat permission check ran as the caller. Fixed in `a6fe8075c30` by
also requiring the owner subject to hold `chat:create`, with
`OwnerWithoutChatPermission` (red on the old head); thread replied to
and resolved.
- Codex review on `a6fe8075c30`: one P2, the active/non-system check was
skipped when the caller could not read the owner's user object. Fixed in
`0dd8bb4dd44` by moving the check behind the authorization gates with a
system-restricted lookup; thread replied to and resolved. In
`62a8be3dd32` that lookup became a single `OrganizationMembers` query,
which also covers membership and excludes system and deleted users.
- Codex review on `62a8be3dd32` (the `owner_id` revision): two P2s. An
explicit zero `owner_id` was treated as omitted and created the chat for
the caller; fixed in `f54b4f33d36` with a 400 and `OwnerIDNil` (red on
the old head). Creation and the read-back still ran as the caller while
the preflight ran as the owner; fixed in the same commit by passing
`ownerCtx` to `CreateChat`, `GetChatByID`, title generation, and the
file-metadata fetch. That second scenario is unreachable today (only the
built-in `owner` role holds `api_key:create` for others, and site-wide
custom roles are refused by both the API and dbauthz), so it has no
dedicated red test. Both threads replied to and resolved.
</details>
<details>
<summary>Remote UAT record (path-based revision)</summary>
Remote UAT on dogfood (chat `d7442df3-693f-4403-805f-2de52f7bdbed`, Xum
sub-agent as critical runner) tested head `21ed6b389cc`, the last
path-based revision. Licensed dev server, real Haiku 4.5 model, 77
logged API requests, 23 inspected screenshots. Endorsed verdict:
**PASS**. Site owner creates a chat for member X: X sees it, gets real
answers to the admin prompt and to follow-ups, and state survives reload
and mid-response refresh. The creating admin gets `403 Only the chat
owner may send messages.` and a read-only view; an unrelated member gets
404. Org admin, member, user-admin, and template-admin callers get 403;
owner-role service account 201. Suspended, dormant, and service-account
targets 400; owner-inaccessible workspace, model config, or MCP server
400; 300 KiB body 413. The `owner_id` revision changes only how the
owner is supplied and the non-member response (400 instead of 404); the
authorization and eligibility gates it exercised are unchanged and
covered by `TestPostChats_OwnerID`.
Non-blocking findings for the author's judgment, none of them
regressions of this PR:
1. X's UI shows no author on the admin-written first message and offers
X "Edit" on it; `created_by` carries the admin but the frontend does not
surface it.
2. A site owner who is not a member of the organization can still create
a chat for its members (201), while a self-owned `POST /chats` returns
403 for the same organization; same asymmetry as `postUserWorkspaces`.
3. The creating admin can archive, rename, and interrupt X's chat
although it cannot message it (pre-existing chat authz).
4. Owner-inaccessible model config or MCP server is reported as "not
found or disabled" with no hint that the owner, not the caller, lacks
access.
5. Dormant (never logged in) targets are refused because AI Bridge
rejects non-active users; a new hire cannot be given a chat until first
login.
6. The endpoint docs list only 201 and 413.
</details>
> Xum (an AI agent) acted on behalf of @ibetitsmike for this PR.
|
||
|
|
2bf0f567d8 |
feat: add OpenAI Pro reasoning mode to chat model configs (#29584)
Adds `provider_options.openai.reasoning_mode` (`pro`) to chat model configs so admins can turn on OpenAI's Pro reasoning mode for a model, alongside the other OpenAI request options on the model form such as `service_tier`. The field is offered for any model on an OpenAI provider; the field description says Pro is supported from the GPT-5.6 Sol generation and that requests fail when Pro is set on a model that does not support it. There is deliberately no supported-model list anywhere: a newly released model that supports Pro works with no code change, and OpenAI rejects the request when the model does not. Validation rejects only values other than `pro`, non-OpenAI providers, and configs that explicitly force plain sampling (`reasoning_model=false`) or Chat Completions (`use_responses_api=false`), including partial updates that move a configured model onto such a provider or transport. A configured mode implies the Responses API and reasoning-model treatment when `openai_config` leaves those unset (`chatprovider.effectiveOpenAIConfig`), so an alias the pinned SDK has never seen, such as `gpt-daybreak-blue-latest`, still gets `effort` and `summary` and drops `temperature`. The same effective config feeds the client options and the recorded transport, so the two cannot disagree. The pinned fantasy OpenAI provider options do not carry `reasoning.mode`, so the mode is applied as a client-scoped `openai-go` request option when the model client is built rather than per call. The SDK merges pre-serialization `WithJSONSet` overlays by top-level key, so the key is escaped (`reasoning\.mode`) to add `mode` to the existing `reasoning` object instead of replacing `effort` and `summary`. `TestResolveModelCallReasoningModeWire` pins the resulting request body for streaming and non-streaming calls and checks that the fixed computer-use model does not inherit the mode; AI Gateway forwarding of the `reasoning` object is covered in `aibridge`. Because the option is bound to the model client, every call made through a Pro model config carries it, including title generation and quick generation when those fall back to the chat's model; deployments that want cheaper auxiliary calls should point the title generation override at another model. Frontend: the field renders through the existing schema-driven provider options with no hand-written field logic. Two generic changes: `visible_for_providers` is now honored for provider fields the way it already was for general fields (render and payload), so the OpenAI-scoped select does not appear or serialize for Azure, which shares the OpenAI field group; and the add/update model save toasts now carry the server's error detail, so a rejected combination such as Pro with Use Responses API at Off tells the admin which field to change. Docs: `docs/ai-coder/agents/models.md` gains a Reasoning Mode row in the OpenAI provider-specific options table (from the documentation check comment https://github.com/coder/coder/pull/29584#issuecomment-5752457808), and its Azure note now says Azure OpenAI lacks that one option. Not changed: `coderd/x/chatd/ARCHITECTURE.md`. Its OpenAI transport selection table needs a `reasoning_mode` row (client-applied, neither transport) to match `TestProviderOptionsTransportParity`; left for the human author. <details> <summary>Delivery record</summary> - Local validation on every pushed head: targeted Go tests (chatopenai, chatprovider, chatd wire test, aibridge integration test, coderd DB tests for persistence, invalid input, and partial updates), red/green on the wire test (injection removed, and unescaped key), Vitest (`modelConfigFormLogic`, `ModelForm`), Storybook tests for `ModelFormProviderConfig`, biome, tsc, oxlint, golangci-lint on touched packages, pre-commit hook. - Codex round 1 on `e7dbaefeafc`: 3 findings (Storybook assertions, ARCHITECTURE.md TODO, `gpt-daybreak-blue-latest` alias). Disposition: assertions moved to Vitest and alias accepted in `8fccf111111`; ARCHITECTURE.md left untouched by author instruction. Threads replied to and resolved. - Codex round 2 on `8fccf111111`: 1 finding (fixture naming, FE9), renamed in `23449e92317`. Round 3 on `23449e92317`: 1 finding (fixture location, FE9), moved to `testHelpers/chatModels.ts` in `c3bd5aa370f`. Round 4 on `c3bd5aa370f`: "Didn't find any major issues" (https://github.com/coder/coder/pull/29584#issuecomment-5735119236). All threads resolved. - Remote UAT round 1 (chat https://dogfood.cdr.dev/agents/f5ed1d16-be1d-4d39-952b-126a6a829ef1) exercised `e7dbaefeafc`: endorsed PASS. Real `gpt-5.6-sol` turns showed `"mode": "pro"` / `"standard"` / no key in the Debug tab with effort and summary intact; 14 POST and 6 PATCH rejections captured; UI select visibility, persistence, reload, and clearing verified. Low, non-blocking notes: the `gpt-5.6` alias revert in the model identifier field is pre-existing; Pro is dropped silently when a model or transport change makes it unsupported; Pro applies to auxiliary calls (see above). - Remote UAT round 2 on `c3bd5aa370f` (same chat, alias and core re-verify): core PASS, alias FAIL. With `gpt-daybreak-blue-latest` the request carried `{"mode": "pro"}` without the configured effort and summary and kept sending `temperature` (provider 400 then retry on quick generation and title calls), because the SDK does not classify the alias as a reasoning model. Fixed in `d4c338de767`: a configured mode now implies a reasoning model unless `openai_config.reasoning_model` is set, and a mode on a config that forces plain sampling is rejected. Alias UI/API behavior, rejections, and known-model Pro/Default turns all passed on `c3bd5aa370f`. - Codex round 5 on `d4c338de767`: "Didn't find any major issues" (https://github.com/coder/coder/pull/29584#issuecomment-5736190356). Zero unresolved threads. CI green on `d4c338de767`. - Remote UAT round 3 on `d4c338de767` (same chat): endorsed PASS. Alias runs are single-attempt 200s with `{"effort", "summary", "mode": "pro"}` and no `temperature` (quick generation and title calls no longer retry); `reasoning_model=false` plus a mode is rejected by POST and PATCH with the stored config unchanged; the Reasoning Model override at Off hides the select and drops the mode on save; `gpt-5.6-sol` Pro turn unchanged. Remaining low notes, none introduced here: rejection detail for a non-OpenAI provider names the model rather than the provider; Pro is dropped silently when an override makes it unsupported; `PATCH model_config` replaces the whole object (pre-existing on main). - coder-frontend-review on `d4c338de767` (8 role reviewers, 3 passes): 13 failing checkpoints, chiefly a TS mirror of the Go model regex, the `json_name === "reasoning_mode"` gate duplicated in the render filter and payload builder, a defaulted `model` parameter, and comment and type nits. Fixed in `554c90d5fd9`: the pattern and provider scope are generated onto the field schema, one predicate is shared by both call sites, `buildModelConfigFromForm(provider, model, form)` requires the model, and the ModelForm test also asserts the select disappears for an unsupported model. Red/green: stripping `supported_models` or `visible_for_providers` from the generated schema fails 21 and 1 Vitest cases respectively. Declined with rationale: RO4 (move the fixture to `ModelsPage/testFixtures.ts`; FE9 in `FRONTEND_PATTERNS.md` names `testHelpers/chatModels.ts`, and Codex round 3 required it) and a DF5 nit to gate on the committed identifier and warn when a saved mode is dropped (behavior change, separate follow-up). Final pass: all checkpoints PASS or N/A. - Remote UAT round 4 on `554c90d5fd9` (same chat, focused regression after the frontend-review refactor): endorsed PASS. All six claims held (Pro round trip with effort and tier intact; unsupported identifiers hide the select and a save drops the stale mode while keeping the other options; Azure never shows or saves it; the alias shows it only with the Responses override On; Reasoning Model Off hides it and drops it; three real `gpt-5.6-sol` Pro turns were single-attempt 200s with `{"effort","summary","mode":"pro"}` and no `temperature`). Probes aimed at the refactor also passed: `gpt-5X6-sol` is rejected (dot escaping survived the JSON round trip), whitespace-padded identifiers still match, the other 11 OpenAI fields and the Anthropic section still render. Remaining low notes are carried over from round 3 plus one naming note ("Reasoning Mode" versus "Reasoning Model"). The final head `abb58df77d8` differs from `554c90d5fd9` only in `ModelForm.test.tsx`, so it ships the same production code. - Codex round 6 on `554c90d5fd9`: 1 finding (https://github.com/coder/coder/pull/29584#pullrequestreview-5260492465): the two `toBeInTheDocument` assertions added in the frontend-review round violate FE1. Confirmed against `site/AGENTS.md`; removed in `abb58df77d8` (test-only, 7 deletions; the payload assertion keeps the behavior coverage and the `ProviderConfigOpenAI` story captures the hidden state). Thread replied to and resolved. - Codex round 7 on `abb58df77d8`: "Didn't find any major issues" (https://github.com/coder/coder/pull/29584#issuecomment-5749626071). Zero unresolved threads. CI green on `abb58df77d8` (23 success, 8 skipped, `required` pass). - Design change on `e99152e5c57` (owner direction: no model gating; "none or pro" for any model; tooltip states the GPT-5.6 Sol constraint and that requests fail on unsupported models). Removed `codersdk.ChatModelReasoningModeModels`, the generated `supported_models`, `isFieldApplicableToModel`, the `gpt-daybreak-blue-latest` special case, and the `standard` enum value; `ValidateReasoningMode(provider, config)` no longer takes the model; `effectiveOpenAIConfig` makes a mode imply Responses and reasoning-model treatment. PR footprint went from +1130/-22 to +769/-18. Local validation: `go test` for chatopenai, chatprovider, chatd wire test, and the coderd API tests (persistence now covers `gpt-5.6-sol`, `gpt-4o`, `gpt-daybreak-blue-latest`, `gpt-7-nova`; invalid input now rejects `standard`), golangci-lint on touched packages, Vitest (187 tests across `modules/aiModels` and `ModelsPage`), biome, tsc, pre-commit hook. - coder-frontend-review on `e99152e5c57` (8 roles, 1 pass plus a TS and CD confirmation pass): 9 failing checkpoints (SD4, CD1, CD3, CD4, TS3, TS7 x2, RO3, RO5, TN4, DF5). Fixed in `e06bfbe4299`: the ModelForm test edits `mockGPT5` so its provider matches the selected provider state, types the update mock like the sibling story, and drops an unused route; the story spreads `mockGPT5` with a saved mode instead of a dedicated shared fixture (`MockGPT56Pro` removed, `testHelpers/chatModels.ts` back to base); a `ProviderConfigAzure` story captures the panel without `reasoning_mode`; comment nits. Left as a nit with justification: RO3 (the one-line `!hidden && isFieldVisibleForProvider` predicate now appears in both `getVisibleProviderFields` and `getVisibleGeneralFields`; hoisting a helper for two call sites is not worth it). Confirmation pass: TS all PASS; CD flagged one wording nit, fixed before commit. - CI green on `e06bfbe4299` (23 success, 8 skipped, `required` pass). - Codex round 8 on `e06bfbe4299`: 1 P2 finding (https://github.com/coder/coder/pull/29584#discussion_r4057659673): the form still offers Pro with Use Responses API or Reasoning Model at Off, a combination the server rejects, and the failure was not actionable. Disposition: the select stays visible by owner direction (no client-side gating of this field beyond the provider scope; an explicit rejection is preferred over the earlier silent drop), and `e2b43c3aee7` makes the add/update save toasts show the server detail so the admin sees which field to change. Thread replied to and resolved; zero unresolved threads. - Remote UAT round 5 on `e06bfbe4299` (same chat): endorsed PASS with two UI issues to land before release. All seven probes passed: the select offers only Default and Pro for `gpt-5.6-sol` and `gpt-4o` with the tooltip text verbatim; Pro saves on `gpt-4o` and the real turn fails visibly with the provider's "reasoning.mode is not supported with this model" after a single 400 attempt, and works again once Pro is cleared; `gpt-daybreak-blue-latest` with Pro and no overrides is a single 200 to `/v1/responses` with `{effort, summary, mode: "pro"}` and no `temperature`; the `gpt-5.6-sol` Pro turn is unchanged; POST and PATCH reject `standard`, `PRO`, empty, Responses Off, Reasoning Model Off, and Azure, openai-compat, and Anthropic providers with the stored config unchanged, while a model-only PATCH to `gpt-4o` now succeeds; the Azure form shows no Reasoning Mode; the alias with an explicit Responses override still works. Reservations: (1) medium, the UI conflict path only showed "Invalid model config." without the detail (fixed in `e2b43c3aee7`, not yet UAT-exercised); (2) low-medium, a dev-DB row still holding `standard` from round 2 renders an empty red select whose message is the whole field description plus "has an invalid value." and blocks saving unrelated fields (pre-existing generic behavior of `yupTestForField` using the description as the label; no released data can hold `standard`, so no migration); (3) low, no hint next to older identifiers (documented design); (4) low, a chat on such a stored row fails with a generic headline (pre-existing). - Final head `e2b43c3aee7` differs from `e06bfbe4299` only in the two save-toast handlers (`AddModelPage.tsx`, `UpdateModelPage.tsx`, 8 insertions). CI is green on `e2b43c3aee7` (skipped=8, success=23, `required` success). Codex has not run on `e2b43c3aee7`. - Remote UAT round 6 on `e2b43c3aee7` (same chat, https://dogfood.cdr.dev/agents/f5ed1d16-be1d-4d39-952b-126a6a829ef1, settled 2026-09-20T19:02Z): endorsed PASS on the exact final head. Build proven by `/api/v2/buildinfo` (`v2.37.2-devel+e2b43c3aee`, `external_url` at the full SHA) and the UI badge. The round 5 toast issue is resolved: Add and Update saves with Pro plus Use Responses API Off or Reasoning Model Off show "Invalid model config." with the server detail as the description, one 400 each, nothing stored. Compact regression of every round 5 probe held (dropdown and tooltip; Pro on `gpt-4o` fails visibly with the provider's `reasoning.mode is not supported with this model` and works after clearing; alias with and without the Responses override and `gpt-5.6-sol` all send `{effort, summary, mode: "pro"}` with no `temperature` in a single 200; POST and PATCH rejection matrices with stored config unchanged; Azure form without the field). Legacy `standard` row: fails closed on chat, and re-picking Pro or Default saves. Remaining notes, none blocking: the malformed validation copy for an invalid stored enum (pre-existing `yupTestForField` label choice, dev-DB rows only), Pro offered for models that cannot accept it (documented design), and a pre-existing `quickgen` status quirk on `gpt-4o` unrelated to this field. Secret scan clean. - Final head `4f3c6106dfe` adds one docs-only commit on top of `e2b43c3aee7` (`docs/ai-coder/agents/models.md`, 9 insertions, 8 deletions, no code). Remote UAT round 6 exercised `e2b43c3aee7`; the docs commit is not UAT-relevant. Validated with `markdown-table-formatter`, `markdownlint-cli2`, and the pre-commit hook (`fmt/markdown`, `lint/markdown`, `lint/emdash`, `lint/typos`). CI is green on `4f3c6106dfe` (success=24, skipped=7, `required` success) and the documentation check re-run marked its item addressed (https://github.com/coder/coder/pull/29584#issuecomment-5752457808). - Review tally for this PR: Codex 8 completed rounds; coder-frontend-review 34 role passes (24 on `d4c338de767`, 10 on `e99152e5c57`); remote UAT 5 rounds; no human review yet. This is far past the six-review guardrail, so no further Codex or agent review has been requested. Whether to spend another Codex pass on `e2b43c3aee7` is an owner decision; human review is still required before merge. </details> > Xum acted on behalf of @ibetitsmike. |
||
|
|
29ae50d9c9 |
feat: accept include_related query param on get workspace by ID (#29539)
Part of the lite `codersdk.Workspace` work ([GRU-82](https://linear.app/codercom/issue/GRU-82), [RFC](https://app.notion.com/p/coderhq/Lite-Workspace-API-Requests-3aad579be5928060b5e7cc65c539717f)). Follows #28639, which added the `wsrelated` package and parser. Wires the `include_related` query parameter into `GET /api/v2/workspaces/{workspace}`, the first endpoint to accept it. When present, the value is parsed with `wsrelated.Parse` and the resulting selection is threaded into `workspaceData`, so only the requested related data is queried. Omitting the parameter is backward compatible and returns everything (`wsrelated.All`). An invalid value returns `400`. Because related data can now be omitted, the handler no longer assumes the build and template are present: it uses zero values when they are absent, and only enforces the template read-authorization check (`403`) when the template was actually requested. ### Partial-build conversion `convertWorkspaceBuilds` now tolerates a build whose provisioner job or template version was deliberately omitted from the selection, so selections such as `latest_build` (build only) or `latest_build.resources.*` (resources without the job) convert correctly instead of erroring. The omitted fields are left zero (empty `Job`, empty `TemplateVersionName`). Resources are keyed by the build's `JobID` rather than the fetched job row, so they load independently of whether the job is selected. The integrity error is preserved for full-data callers: when a job or template version is requested but missing, conversion still fails. The selection config (`wsrelated.LatestBuild`) is threaded into `convertWorkspaceBuilds` to distinguish "not requested" from "missing". Only this endpoint is wired; the other endpoints that produce `codersdk.Workspace` objects, and the codersdk client functions, come in later PRs. --- *Generated by Coder Agents on behalf of @spikecurtis.* |
||
|
|
9974294ca9 |
feat: report arbitrary workspace agent session types (#28338)
Report session counts as a dynamic app-name map from the agent, the SSH CLI, and the workspace usage API, so a new IDE flows end to end without a schema, proto, or server change. - Report through `Stats.session_counts` on Agent API v2.11. Older agents keep reporting through the deprecated count fields. - Accept arbitrary names from `coder ssh --usage-app` and the workspace usage API. A name the registry does not recognize keeps its identity and is attributed to the `unknown` family. - Add reconnecting PTY counts to the map without overwriting the counts SSH reported. - Normalize and merge names before applying the deterministic 64-name cap, ordered by known apps, then count, then name. Overflow sums into `unknown`, and non-positive counts cannot cancel valid activity. - Strip control characters, treat whitespace-only HTTP app names as absent, and require the exact environment variable prefix when you extract an SSH session type. - Count overflow entries in `coderd_agentstats_session_counts_overflow_total` and keep raw payloads out of logs. - Change the usage API's `app_name` to a string, and update the SDK types and API reference. closes #27410 |
||
|
|
55da502938 |
feat: allow admins to configure an OAuth2 app's scope allowlist (#29313)
Add backend support for scope allowlists on admin-created OAuth2 apps, previously available only through DCR. - Add optional, space-separated `scope` to create/update requests and return canonicalized, deduplicated scopes in app responses. - On create, omitted or empty `scope` means unrestricted. On update, `scope` replaces the allowlist; omission preserves it, and an empty string clears it to unrestricted. - Keep scope enforcement unchanged. Add tests for scope round-trips, DCR canonicalization parity, and authorization narrowing. - Include generated SDK and docs updates. The UI scope picker follows in a separate PR. Part of [PLAT-475](https://linear.app/codercom/issue/PLAT-475). |
||
|
|
8e159a8053 | chore: remove stale TODO shims and dead code (#29252) | ||
|
|
c8b22a9d80 |
feat: add filters to the AI spend CSV endpoint (#29414)
## Description Update the existing CSV export endpoint and SDK to accept user, effective group, provider name, and model filters. ## Changes - Pass the requested filters to the database query. - Validate filters alongside the existing time window. - Continue downloading all matching rows without pagination. > [!NOTE] > Generated by Coder Agents on behalf of @ssncferreira. |
||
|
|
19076beb8d |
feat: attribute AI Gateway usage to workspaces (#29235)
- Adds nullable `workspace_id` to AI Gateway interceptions without a foreign key or index. - Derives direct attribution from strictly parsed server-minted workspace session-token names, excluding user-created tokens and validating the embedded owner. - Derives delegated Coder Agents attribution from the persisted chat workspace ID. - Records `workspace_id` through the additive v1.3 gateway protocol and structured interception logs. - Exposes attribution in session details through `interception_attributions`, including tool-less interceptions and null values for unknown attribution. Closes AIGOV-637 Generated by Coder Agents. |
||
|
|
aae145bdc9 |
feat: make NATS pubsub opt-out via no_nats_pubsub experiment (#29283)
Makes the embedded NATS pubsub an opt-out feature instead of opt-in. The `nats_pubsub` experiment is removed and replaced with a `no_nats_pubsub` experiment, so NATS pubsub is now the default and can be disabled to fall back to PostgreSQL pubsub. NATS clustering requires this replica's routable address, resolved into `clusterHost` from either `--cluster-host` (`CODER_CLUSTER_HOST`) or the DERP relay URL. When neither is set (allowed when DERP is disabled on the primary), NATS cannot form a cluster, so startup logs a big error and falls back to PostgreSQL pubsub. The NATS cluster CA is only minted/rotated when NATS clustering is actually active (experiment not set and a cluster host is present). <details> <summary>Implementation notes</summary> - `codersdk/deployment.go`: removed `ExperimentNATSPubsub` (`nats_pubsub`), added `ExperimentNoNATSPubsub` (`no_nats_pubsub`, display name "No NATS Pubsub"). - `cli/server.go`: NATS is used by default unless `no_nats_pubsub` is enabled; if `clusterHost` is empty, log an error and keep the PostgreSQL pubsub. - `coderd/coderd.go`: gate NATS CA minting/rotation on `!ExperimentNoNATSPubsub && ClusterHost != ""` (i.e. only when NATS clustering is active). - `enterprise/coderd/licenses.go`: updated a stale comment. - `enterprise/coderd/coderd_test.go`: `TestMultiReplica_NATSPubsubPeers` no longer sets the removed experiment. - Regenerated `coderd/apidoc/docs.go`, `coderd/apidoc/swagger.json`, `docs/reference/api/schemas.md`, `site/src/api/typesGenerated.ts`. </details> --- *This PR was generated by Coder Agents on behalf of @spikecurtis.* |