@coder/ai-sdk-agent 0.9.14 → 0.10.1

package/README.md

@@ -10,8 +10,9 @@ AI SDK's [`Agent`](https://ai-sdk.dev/docs/reference/ai-sdk-core/agent) interfac
 (`generate()` / `stream()`). Script it, stream from it, and attach your own tools —
 exactly like the SDK's own `ToolLoopAgent`.
 
-> Status: works end‑to‑end against Coder's experimental chat API (`/api/experimental/chats`).
-> Both the Coder API and this package are pre‑1.0; expect change.
+> Status: targets Coder's stable chat API (`/api/v2/chats`), available since
+> Coder 2.37.0 (September 1, 2026). This package remains pre‑1.0.
+> See [API compatibility](#api-compatibility) for older deployments.
 
 ## Why
 
@@ -58,7 +59,7 @@ import { tool } from "ai";
 import { z } from "zod";
 
 const agent = new CoderAgent({
-  baseUrl: "https://dev.coder.com",
+  baseUrl: "https://dogfood.cdr.dev",
   token: process.env.CODER_SESSION_TOKEN!, // Coder API/session token
   organizationId: "703f72a1-…", // your org UUID
   model: "claude-sonnet-4-6", // hint: UUID, provider:model, model id, or display-name substring
@@ -90,7 +91,7 @@ of the AI SDK.
 Runnable scripts live in [`examples/`](./examples) (run against a real deployment via `tsx`):
 
 ```bash
-export CODER_URL=https://dev.coder.com
+export CODER_URL=https://dogfood.cdr.dev
 export CODER_SESSION_TOKEN=$(coder tokens create --name coderagent-example)
 
 pnpm example:generate     # non-streaming generate()
@@ -213,6 +214,30 @@ const client = new CoderChatClient({ baseUrl, token });
 const agent = new CoderAgent({ client, organizationId });
 ```
 
+## API compatibility
+
+Coder 2.37.0 promoted chat routes to `/api/v2/chats`
+([server routes](https://github.com/coder/coder/pull/28496),
+[Go SDK](https://github.com/coder/coder/pull/28497)). The promoted routes also
+remain under `/api/experimental/chats` during the compatibility window
+(CODAGT-921); legacy removal is tracked in CODAGT-922. Coder 2.36.4 has no stable
+chat mount.
+
+Each `CoderChatClient` selects its chat prefix from HTTP responses, not version
+strings. Until selected, an actual REST request (including JSON requests and
+`Blob` uploads) tries v2 first and retries once under the experimental prefix
+only on 404. The first non-404 HTTP response
+(including an error) locks that prefix for the client's lifetime; concurrent
+unresolved calls may probe independently, with the first conclusive response
+winning. Two 404s preserve the original v2 error without locking; non-HTTP
+failures do not lock either. A locked prefix is never renegotiated, even on 404.
+Before opening a per-chat `/stream` or global `/watch` WebSocket, an unresolved
+client preflights with `GET /api/v2/chats` using the same selection rules and
+cancellation signal.
+`ReadableStream` uploads also preflight so their consumed bodies are never
+replayed. Legacy model-config lookup remains independent of chat-prefix
+selection (see [Configuration](#configuration)).
+
 ## Sessions
 
 One `CoderAgent` instance maps to one chat ("session") on the Coder server. The chat is
@@ -282,7 +307,7 @@ chatMessagesToUIMessages(messages, {
 
 `client.watchChats({ signal })` yields lifecycle events (status/title changes,
 creation, deletion, …) for **every chat visible to the authenticated user** as an
-async iterable, backed by the `/api/experimental/chats/watch` WebSocket:
+async iterable, backed by the `/api/v2/chats/watch` WebSocket:
 
 ```ts
 for await (const event of client.watchChats({ signal })) {
@@ -290,14 +315,16 @@ for await (const event of client.watchChats({ signal })) {
 }
 ```
 
-Unlike the per‑chat event stream, this is a long‑lived subscription: dropped
-connections are redialed automatically with exponential backoff (1s doubling to
-a 30s cap, reset once an event arrives). Iteration ends only when the signal
-aborts, or with a terminal `CoderApiError` when the server rejects the upgrade
-with a 4xx — bad/expired token, or an older Coder server without the endpoint
-(404). For custom plumbing (own client, browser sockets), the standalone
-`watchChatEvents({ baseUrl, token, signal, webSocketFactory })` export provides
-the same stream without a `CoderChatClient`.
+After [prefix selection](#api-compatibility) (whose preflight errors propagate),
+this is a long‑lived subscription: dropped connections are redialed automatically
+with exponential backoff (1s doubling to a 30s cap, reset once an event arrives).
+Aborting the signal or ending iteration tears down the reader. A 4xx upgrade
+rejection throws a terminal `CoderApiError` — bad/expired token, or an older
+Coder server without the endpoint (404). For custom plumbing (own client,
+browser sockets), the standalone
+`watchChatEvents({ baseUrl, token, signal, webSocketFactory })` export defaults
+to the stable prefix without preflighting; use `CoderChatClient` for automatic
+prefix selection.
 
 ## Observability
 
@@ -365,7 +392,9 @@ Semantics worth knowing:
   `"getMessages"`, `"submitToolResults"`, … — the `CoderClientOperation`
   union), so per‑operation classification never has to reverse‑engineer
   `path`. `method`/`path` stay for generic consumers; `archiveChat` stamps its
-  own `op` even though it issues the same `PATCH` as `updateChat`.
+  own `op` even though it issues the same `PATCH` as `updateChat`. WebSocket
+  prefix-selection preflights emit the existing `http:*` event kinds with
+  `op: "streamEvents"` or `op: "watchChats"` — no new event kinds.
 - `ws:event` fires at arrival: after a redial, chatd's replay of the
   in‑progress episode is visible here (correlate with `reader`/`attempt`),
   stamped with the reader's own replay verdict — `forwarded: false` exactly on
@@ -559,7 +588,7 @@ are mirrored the same way under each step's `providerMetadata.coder`
 `result.steps[*].providerMetadata.coder` for whole‑turn cost when client tools
 ran). Both are **absence‑tolerant mirrors**: on servers that don't send them
 (cost is otherwise only on the aggregate cost endpoints,
-`/api/experimental/chats/cost/*`), nothing is emitted.
+`/api/v2/chats/cost/*`), nothing is emitted.
 
 Forward usage to a UI via message metadata:
 
@@ -865,7 +894,7 @@ status indefinitely. Defend in this order:
    cursor or replay), so a chat already stuck before the watcher started — or
    one that transitioned during a gap — never emits an event to start your
    timer from. Seed and periodically reconcile against a chat listing
-   (`GET /api/experimental/chats`) instead of trusting the event stream alone.
+   (`GET /api/v2/chats`) instead of trusting the event stream alone.
 
 ### Troubleshooting: unschedulable & stuck chats
 
@@ -912,9 +941,10 @@ is used as‑is, then an exact `provider:model` match, an exact model id, a
 display‑name substring (case‑insensitive), and finally a model‑id substring.
 On older deployments where the organization‑scoped route does not exist yet
 (404), resolution falls back once to the legacy deployment‑wide
-`/model-configs` listing. Partial payloads from older/newer servers are
-tolerated (entries match on the fields they carry), and an unresolvable hint
-falls back to the server's default model instead of failing. Use
+`/api/experimental/chats/model-configs` listing, independently of chat-prefix
+selection. Partial payloads from older/newer servers are tolerated (entries
+match on the fields they carry), and an unresolvable hint falls back to the
+server's default model instead of failing. Use
 `agent.listModels()` to see what's available.
 
 ## How it works
@@ -923,7 +953,7 @@ falls back to the server's default model instead of failing. Use
 CoderAgent  (implements ai.Agent)
   └─ ToolLoopAgent (ai)            ← inherits generate()/stream(), loop control
        └─ CoderLanguageModel       ← implements @ai-sdk/provider LanguageModelV4
-            └─ CoderChatClient      ← REST + WebSocket to /api/experimental/chats
+            └─ CoderChatClient      ← REST + WebSocket to /api/v2/chats
                  └─ Coder Agents     ← runs the agent loop SERVER-side
 ```
 
@@ -1734,13 +1764,13 @@ live chats.
 
 ```ts
 export async function archiveWorkflowChat(workflowId: string): Promise<void> {
-  const chatId = await checkpoints.get(workflowId);
-  if (!chatId) return; // the workflow died before its first turn created a chat
+  const checkpoint = await checkpoints.get(workflowId);
+  if (!checkpoint) return; // the workflow died before its first turn created a chat
   const agent = new CoderAgent({
     baseUrl: process.env.CODER_URL!,
     token: process.env.CODER_SESSION_TOKEN!,
     organizationId: process.env.CODER_ORG_ID!,
-    chatId,
+    chatId: checkpoint.chatId,
   });
   // A crashed step may have left a run live — stop it first, bounded. On an
   // already-settled chat the interrupt rejects with a 409; ignore it.
@@ -1782,7 +1812,7 @@ pnpm build
 End‑to‑end tests run against a live Coder deployment and are opt‑in via env:
 
 ```bash
-CODER_URL=https://dev.coder.com \
+CODER_URL=https://dogfood.cdr.dev \
 CODER_SESSION_TOKEN=$(coder tokens create --name e2e) \
 pnpm test:e2e
 ```
@@ -1791,7 +1821,8 @@ The e2e suite creates **new chats only** (no workspaces) and archives them after
 
 ## Limitations
 
-- The Coder chat API is experimental (`/api/experimental/chats`); wire types may change.
+- Older deployments use a temporary experimental-route fallback; it is not a
+  guarantee that every chat feature is available (see [API compatibility](#api-compatibility)).
 - Designed for Node (WebSocket via `ws`); a browser build can inject a `webSocketFactory`.
 - A v7 `@ai-sdk/harness` adapter (the conceptually exact fit) is a future direction once that
   experimental API stabilizes.

package/dist/index.d.ts

@@ -48,12 +48,10 @@ declare function resolveFileContent(content: FileContent, opts?: {
 declare function dataContentToFileContent(data: SharedV4FileData): FileContent;
 
 /**
- * Wire types for Coder's experimental `chatd` chat API
- * (`/api/experimental/chats`). These mirror the Go types in
+ * Wire types for Coder's stable `chatd` chat API
+ * (`/api/v2/chats`, promoted in Coder 2.37.0). These mirror the Go types in
  * `coder/coder`'s `codersdk/chats.go` (JSON shapes), restricted to the subset
  * this client uses. Field names use snake_case to match the wire format.
- *
- * NOTE: The chatd API is experimental and may change between Coder releases.
  */
 type ChatInputPartType = "text" | "file" | "file-reference";
 interface ChatInputPart {
@@ -67,7 +65,7 @@ interface ChatInputPart {
 }
 /**
  * Media types accepted by the chat-file upload endpoint
- * (`POST /api/experimental/chats/files`). The server allowlist is intentionally
+ * (`POST /api/v2/chats/files`). The server allowlist is intentionally
  * narrow — anything else (zip, tarball, binaries, …) is not a chat attachment
  * and belongs on the workspace filesystem instead. Mirrors
  * `codersdk.AllChatAttachmentMediaTypes`.
@@ -240,7 +238,7 @@ interface ChatMessagesResponse {
     queued_messages: ChatQueuedMessage[];
     has_more: boolean;
 }
-/** Response from `POST /api/experimental/chats/files`: the uploaded file's id. */
+/** Response from `POST /api/v2/chats/files`: the uploaded file's id. */
 interface UploadChatFileResponse {
     id: string;
 }
@@ -363,7 +361,7 @@ declare const TERMINAL_STATUSES: ReadonlySet<ChatStatus>;
 /** Kinds of chat lifecycle events emitted on the per-user watch socket. */
 type ChatWatchEventKind = "status_change" | "summary_change" | "title_change" | "created" | "deleted" | "diff_status_change" | "action_required" | "context_dirty";
 /**
- * An event from `GET /api/experimental/chats/watch`, which covers every chat
+ * An event from `GET /api/v2/chats/watch`, which covers every chat
  * visible to the authenticated user (not a single chat). Mirrors
  * `codersdk.ChatWatchEvent`.
  */
@@ -409,7 +407,7 @@ interface TransportEventBase {
  * extend this union; treat unrecognized values as "some other operation"
  * rather than matching exhaustively.
  */
-type CoderClientOperation = "listModelConfigs" | "resolveModelConfigId" | "createChat" | "getChat" | "createChatMessage" | "getMessages" | "submitToolResults" | "interruptChat" | "deleteQueuedMessage" | "updateChat" | "archiveChat" | "uploadChatFile" | "getChatFile";
+type CoderClientOperation = "listModelConfigs" | "resolveModelConfigId" | "createChat" | "getChat" | "createChatMessage" | "getMessages" | "submitToolResults" | "interruptChat" | "deleteQueuedMessage" | "updateChat" | "archiveChat" | "uploadChatFile" | "getChatFile" | "streamEvents" | "watchChats";
 interface HttpTransportEventBase extends TransportEventBase {
     /**
      * Correlates a request with its response/error. Monotonically increasing
@@ -426,7 +424,7 @@ interface HttpTransportEventBase extends TransportEventBase {
     method: string;
     /**
      * Path + query relative to the client's `baseUrl`, e.g.
-     * `/api/experimental/chats/{id}/tool-results`. Never carries credentials.
+     * `/api/v2/chats/{id}/tool-results`. Never carries credentials.
      */
     path: string;
 }
@@ -639,6 +637,8 @@ interface StreamChatEventsOptions {
     afterId?: number;
     signal?: AbortSignal;
     webSocketFactory?: WebSocketFactory;
+    /** Resolve the client's route prefix before dialing, using the reader's cancellation signal. */
+    resolveApiPrefix?: (signal: AbortSignal) => Promise<string>;
     /**
      * Observability hook: receives the reader's `ws:*` transport events (dial,
      * open, decoded events, close, error, redial). Exceptions it throws are
@@ -695,6 +695,8 @@ interface WatchChatEventsOptions {
     token: string;
     signal?: AbortSignal;
     webSocketFactory?: WebSocketFactory;
+    /** Resolve the client's route prefix before dialing, using the reader's cancellation signal. */
+    resolveApiPrefix?: (signal: AbortSignal) => Promise<string>;
 }
 /**
  * Opens the chatd `/watch` WebSocket — lifecycle events for every chat visible
@@ -731,7 +733,7 @@ interface UploadedChatFile {
     name?: string;
 }
 interface CoderChatClientOptions {
-    /** Base URL of the Coder deployment, e.g. `https://dev.coder.com`. */
+    /** Base URL of the Coder deployment, e.g. `https://dogfood.cdr.dev`. */
     baseUrl: string;
     /** Coder API token or session token (sent as `Coder-Session-Token`). */
     token: string;
@@ -748,8 +750,8 @@ interface CoderChatClientOptions {
     onTransportEvent?: TransportEventHandler;
 }
 /**
- * A thin, typed client for Coder's experimental `chatd` API. This is a
- * TypeScript port of the chat surface of `codersdk.ExperimentalClient`.
+ * A thin, typed client for Coder's chat API, using stable routes with a
+ * per-instance experimental-prefix fallback for deployments before v2.37.0.
  */
 declare class CoderChatClient {
     #private;
@@ -830,10 +832,12 @@ declare class CoderChatClient {
     /**
      * Watch lifecycle events (status/title changes, creation, deletion, …) for
      * every chat visible to the authenticated user via the `/chats/watch`
-     * WebSocket. Dropped connections are redialed with exponential backoff; the
-     * iteration ends only when `opts.signal` aborts, or with a terminal
-     * {@link CoderApiError} when the server rejects the upgrade with a 4xx
-     * (bad/expired token, or an older Coder server without the endpoint → 404).
+     * WebSocket. An unresolved client first probes the REST chat listing;
+     * probe failures propagate unless the reader was cancelled. Once connected,
+     * dropped connections are redialed with exponential backoff. Aborting the
+     * signal or ending iteration tears down the reader; a 4xx upgrade rejection
+     * is a terminal {@link CoderApiError} (bad/expired token, or an older Coder
+     * server without the endpoint → 404).
      */
     watchChats(opts?: {
         signal?: AbortSignal;
@@ -974,7 +978,7 @@ interface CoderAgentSettings<TOOLS extends ToolSet = {}> {
      * set `CODER_URL` + `CODER_SESSION_TOKEN`) to enable them.
      */
     client?: CoderChatClient;
-    /** Coder deployment base URL, e.g. `https://dev.coder.com`. Defaults to `CODER_URL`. */
+    /** Coder deployment base URL, e.g. `https://dogfood.cdr.dev`. Defaults to `CODER_URL`. */
     baseUrl?: string;
     /** Coder API/session token (sent as `Coder-Session-Token`). Defaults to `CODER_SESSION_TOKEN`. */
     token?: string;

package/dist/index.js

@@ -261,7 +261,15 @@ async function* streamChatEventsLoop(options) {
   const emit = safeTransportEmitter(options.onTransportEvent);
   let attempt = 0;
   const wsBase = httpToWs(baseUrl);
-  const path = `/api/experimental/chats/${chatId}/stream`;
+  if (signal.aborted) return;
+  let prefix = "/api/v2/chats";
+  try {
+    if (options.resolveApiPrefix) prefix = await options.resolveApiPrefix(signal);
+  } catch (err) {
+    if (signal.aborted) return;
+    throw err;
+  }
+  const path = `${prefix}/${chatId}/stream`;
   const query = options.afterId !== void 0 ? `?after_id=${options.afterId}` : "";
   const url = `${wsBase}${path}${query}`;
   let maxCommittedId = options.afterId;
@@ -480,7 +488,6 @@ async function* streamChatEventsLoop(options) {
     backoffMs = Math.min(backoffMs * 2, STREAM_BACKOFF_CAP_MS);
   }
 }
-var WATCH_PATH = "/api/experimental/chats/watch";
 var WATCH_BACKOFF_INITIAL_MS = 1e3;
 var WATCH_BACKOFF_CAP_MS = 3e4;
 function sleep(ms, signal) {
@@ -558,7 +565,16 @@ function watchChatEvents(options) {
 async function* watchChatEventsLoop(options) {
   const { baseUrl, token, signal } = options;
   const factory = options.webSocketFactory ?? defaultFactory;
-  const url = `${httpToWs(baseUrl)}${WATCH_PATH}`;
+  if (signal.aborted) return;
+  let prefix = "/api/v2/chats";
+  try {
+    if (options.resolveApiPrefix) prefix = await options.resolveApiPrefix(signal);
+  } catch (err) {
+    if (signal.aborted) return;
+    throw err;
+  }
+  const path = `${prefix}/watch`;
+  const url = `${httpToWs(baseUrl)}${path}`;
   let backoffMs = WATCH_BACKOFF_INITIAL_MS;
   while (!signal?.aborted) {
     const queue = [];
@@ -609,7 +625,7 @@ async function* watchChatEventsLoop(options) {
       if (finished) return;
       const message = ev && typeof ev === "object" && "message" in ev ? String(ev.message) : "chat watch socket error";
       const status = upgradeStatus(message);
-      failure = status !== void 0 && status >= 400 && status < 500 ? new CoderApiError({ status, method: "GET", path: WATCH_PATH, message }) : new CoderAgentError(message);
+      failure = status !== void 0 && status >= 400 && status < 500 ? new CoderApiError({ status, method: "GET", path, message }) : new CoderAgentError(message);
       finished = true;
       wake();
     };
@@ -652,7 +668,8 @@ async function* watchChatEventsLoop(options) {
 }
 
 // src/coder/client.ts
-var API_PREFIX = "/api/experimental/chats";
+var API_PREFIX = "/api/v2/chats";
+var LEGACY_API_PREFIX = "/api/experimental/chats";
 var CoderChatClient = class {
   baseUrl;
   #token;
@@ -663,6 +680,7 @@ var CoderChatClient = class {
   /** Exception-isolated emitter for this client's own HTTP events. */
   #emitTransportEvent;
   #httpSeq = 0;
+  #apiPrefix;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/$/, "");
     this.#token = options.token;
@@ -678,7 +696,7 @@ var CoderChatClient = class {
    * public client method on the exchange's `http:*` events (issue #112) — the
    * emit site is shared, so each call site threads its own literal.
    */
-  async #send(op, method, path, opts) {
+  async #sendOnce(op, method, path, opts) {
     const headers = {
       "Coder-Session-Token": this.#token,
       ...opts?.headers
@@ -734,6 +752,65 @@ var CoderChatClient = class {
     }
     return res;
   }
+  /**
+   * Negotiate promoted chat routes from responses, not buildinfo versions:
+   * v2.37.0 introduced /api/v2/chats (coder/coder#28496), while patched older
+   * releases still only mount /api/experimental/chats. Retry a v2 404 once on
+   * experimental; the first non-404 HTTP response locks the prefix for this
+   * client. Network/abort failures cannot establish route support. Two 404s
+   * preserve the original v2 error (possibly a missing resource) and leave
+   * negotiation open for the next call. A locked client never falls back.
+   *
+   * Concurrent initial calls may probe in parallel; a late response cannot
+   * overwrite the first lock. Model listings use separate routes/fallbacks
+   * and must neither consult nor establish this chat-prefix lock.
+   */
+  async #send(op, method, path, opts) {
+    if (path !== API_PREFIX && !path.startsWith(`${API_PREFIX}/`)) {
+      return this.#sendOnce(op, method, path, opts);
+    }
+    const suffix = path.slice(API_PREFIX.length);
+    if (this.#apiPrefix) {
+      return this.#sendOnce(op, method, `${this.#apiPrefix}${suffix}`, opts);
+    }
+    try {
+      const res = await this.#sendOnce(op, method, path, opts);
+      this.#apiPrefix ??= API_PREFIX;
+      return res;
+    } catch (err) {
+      if (!(err instanceof CoderApiError)) throw err;
+      if (err.status !== 404) {
+        this.#apiPrefix ??= API_PREFIX;
+        throw err;
+      }
+      if (this.#apiPrefix === API_PREFIX) throw err;
+      try {
+        const res = await this.#sendOnce(op, method, `${LEGACY_API_PREFIX}${suffix}`, opts);
+        this.#apiPrefix ??= LEGACY_API_PREFIX;
+        return res;
+      } catch (legacyErr) {
+        if (legacyErr instanceof CoderApiError) {
+          if (legacyErr.status === 404) throw err;
+          this.#apiPrefix ??= LEGACY_API_PREFIX;
+        }
+        throw legacyErr;
+      }
+    }
+  }
+  /**
+   * Resolve before a WebSocket dial or a non-replayable streaming upload. A
+   * read-only listing avoids consuming the upload body and works even without
+   * a chat id (/watch). The WS reader supplies its internal cancellation signal
+   * so return()/throw()/async disposal can also cancel an in-flight probe.
+   */
+  async #resolveApiPrefix(op, signal) {
+    if (!this.#apiPrefix) {
+      const res = await this.#send(op, "GET", API_PREFIX, { signal });
+      await res.body?.cancel();
+    }
+    if (!this.#apiPrefix) throw new CoderAgentError("Chat route probe succeeded without a prefix");
+    return this.#apiPrefix;
+  }
   /** Read a response body as JSON, tolerating an unreadable/empty/malformed body (→ undefined). */
   async #json(res) {
     const text = await res.text().catch(() => "");
@@ -884,6 +961,9 @@ var CoderChatClient = class {
       );
       headers["Content-Disposition"] = `attachment; filename="${ascii}"; filename*=UTF-8''${utf8}`;
     }
+    if (resolved.body instanceof ReadableStream) {
+      await this.#resolveApiPrefix("uploadChatFile", signal);
+    }
     const res = await this.#send(
       "uploadChatFile",
       "POST",
@@ -895,7 +975,7 @@ var CoderChatClient = class {
       throw new CoderApiError({
         status: res.status,
         method: "POST",
-        path: `${API_PREFIX}/files`,
+        path: `${this.#apiPrefix}/files`,
         message: "upload succeeded but the response contained no file id"
       });
     }
@@ -918,6 +998,7 @@ var CoderChatClient = class {
       baseUrl: this.baseUrl,
       token: this.#token,
       chatId,
+      resolveApiPrefix: (signal) => this.#resolveApiPrefix("streamEvents", signal),
       afterId: opts?.afterId,
       signal: opts?.signal,
       reader: opts?.reader,
@@ -928,15 +1009,18 @@ var CoderChatClient = class {
   /**
    * Watch lifecycle events (status/title changes, creation, deletion, …) for
    * every chat visible to the authenticated user via the `/chats/watch`
-   * WebSocket. Dropped connections are redialed with exponential backoff; the
-   * iteration ends only when `opts.signal` aborts, or with a terminal
-   * {@link CoderApiError} when the server rejects the upgrade with a 4xx
-   * (bad/expired token, or an older Coder server without the endpoint → 404).
+   * WebSocket. An unresolved client first probes the REST chat listing;
+   * probe failures propagate unless the reader was cancelled. Once connected,
+   * dropped connections are redialed with exponential backoff. Aborting the
+   * signal or ending iteration tears down the reader; a 4xx upgrade rejection
+   * is a terminal {@link CoderApiError} (bad/expired token, or an older Coder
+   * server without the endpoint → 404).
    */
   watchChats(opts) {
     return watchChatEvents({
       baseUrl: this.baseUrl,
       token: this.#token,
+      resolveApiPrefix: (signal) => this.#resolveApiPrefix("watchChats", signal),
       signal: opts?.signal,
       webSocketFactory: this.#webSocketFactory
     });
@@ -972,7 +1056,7 @@ var CoderChatClient = class {
       const raw = await this.#request(
         op,
         "GET",
-        `${API_PREFIX}/model-configs`,
+        `${LEGACY_API_PREFIX}/model-configs`,
         void 0,
         signal
       );