@tai42/api-client 20.0.0 → 22.0.0

package/src/client/conversations-client.ts

@@ -1,5 +1,5 @@
 /** Conversation route, thread, transcript, config and admin sub-client. */
-import { encodeSegment } from '../http';
+import { apiRoutes, buildPath } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -63,22 +63,32 @@ function conversationRouteMethods(t: Transport) {
     // The stored routing rows, each with its `callback_secret` withheld — the
     // conversation monitor's route picker.
     listConversationRoutes: (signal?: AbortSignal) =>
-      req('/api/conversations', s.conversationRoutes, { signal }),
+      req(apiRoutes.get_api_conversations.path, s.conversationRoutes, { signal }),
     // Create or REPLACE a route (an UPSERT: the same door is the create and the
     // edit path). `route_name` rides the URL path AND the body; the door rejects a
     // disagreeing pair, so both come from the one create object. The reply carries
     // the freshly-minted `callback_secret` for an `api`-door row, returned ONCE.
     createOrReplaceConversationRoute: (route: s.ConversationRouteCreate) =>
-      req(`/api/conversations/${encodeSegment(route.route_name)}`, s.conversationRouteWritten, {
-        method: 'POST',
-        body: route,
-      }),
+      req(
+        buildPath(apiRoutes.post_api_conversations_route_name.path, {
+          route_name: route.route_name,
+        }),
+        s.conversationRouteWritten,
+        {
+          method: 'POST',
+          body: route,
+        },
+      ),
     // Delete a route by name (destructive + authority-changing server-side): it
     // drops the routing row and reclaims the thread indexes it owned.
     deleteConversationRoute: (routeName: string) =>
-      req(`/api/conversations/${encodeSegment(routeName)}`, s.conversationRouteDeleted, {
-        method: 'DELETE',
-      }),
+      req(
+        buildPath(apiRoutes.delete_api_conversations_route_name.path, { route_name: routeName }),
+        s.conversationRouteDeleted,
+        {
+          method: 'DELETE',
+        },
+      ),
   };
 }
 
@@ -95,10 +105,16 @@ function conversationThreadMethods(t: Transport) {
       filters: ConversationThreadFilters = {},
       signal?: AbortSignal,
     ) =>
-      req(`/api/conversations/${encodeSegment(routeName)}/threads`, s.conversationThreadsPage, {
-        signal,
-        query: { page, pageSize, status: filters.status, address: filters.address },
-      }),
+      req(
+        buildPath(apiRoutes.get_api_conversations_route_name_threads.path, {
+          route_name: routeName,
+        }),
+        s.conversationThreadsPage,
+        {
+          signal,
+          query: { page, pageSize, status: filters.status, address: filters.address },
+        },
+      ),
     // One thread's transcript, caller-scoped, read in the asked-for direction.
     // The `thread_id` rides the QUERY STRING, never the path: it embeds the api
     // door's `{principal}/{end user}` address with the principal already
@@ -107,7 +123,9 @@ function conversationThreadMethods(t: Transport) {
     // exactly once whatever it holds, so it is passed through verbatim.
     readConversationTranscript: (query: ConversationTranscriptQuery, signal?: AbortSignal) =>
       req(
-        `/api/conversations/${encodeSegment(query.routeName)}/transcript`,
+        buildPath(apiRoutes.get_api_conversations_route_name_transcript.path, {
+          route_name: query.routeName,
+        }),
         s.conversationTranscriptPage,
         {
           signal,
@@ -125,7 +143,9 @@ function conversationThreadMethods(t: Transport) {
     // page's `truncated` flag says the match set outran the door's scan cap.
     searchConversationMessages: (query: ConversationMessageSearchQuery, signal?: AbortSignal) =>
       req(
-        `/api/conversations/${encodeSegment(query.routeName)}/messages/search`,
+        buildPath(apiRoutes.get_api_conversations_route_name_messages_search.path, {
+          route_name: query.routeName,
+        }),
         s.conversationMessageSearchPage,
         { signal, query: { q: query.q, page: query.page, pageSize: query.pageSize } },
       ),
@@ -133,7 +153,9 @@ function conversationThreadMethods(t: Transport) {
     // never a path segment) — same encode-once reasoning as the transcript read.
     sendConversationThreadMessage: (routeName: string, body: ConversationThreadMessageBody) =>
       req(
-        `/api/conversations/${encodeSegment(routeName)}/thread/messages`,
+        buildPath(apiRoutes.post_api_conversations_route_name_thread_messages.path, {
+          route_name: routeName,
+        }),
         s.conversationThreadMessageSent,
         { method: 'POST', body },
       ),
@@ -141,7 +163,9 @@ function conversationThreadMethods(t: Transport) {
     // `thread_id` rides the QUERY value, encoded once, as the transcript read does.
     getConversationThreadMode: (routeName: string, threadId: string, signal?: AbortSignal) =>
       req(
-        `/api/conversations/${encodeSegment(routeName)}/thread/mode`,
+        buildPath(apiRoutes.get_api_conversations_route_name_thread_mode.path, {
+          route_name: routeName,
+        }),
         s.conversationThreadModeState,
         { signal, query: { thread_id: threadId } },
       ),
@@ -152,7 +176,9 @@ function conversationThreadMethods(t: Transport) {
       mode: s.ConversationThreadMode,
     ) =>
       req(
-        `/api/conversations/${encodeSegment(routeName)}/thread/mode`,
+        buildPath(apiRoutes.put_api_conversations_route_name_thread_mode.path, {
+          route_name: routeName,
+        }),
         s.conversationThreadModeState,
         { method: 'PUT', body: { thread_id: threadId, mode } },
       ),
@@ -166,7 +192,7 @@ function conversationConfigMethods(t: Transport) {
     // The stored per-target presentation configs (each `(target_kind, target_name)`
     // pair's multichannel flag + first-contact greeting). Admin config surface.
     listConversationConfigs: (signal?: AbortSignal) =>
-      req('/api/conversation-configs', s.conversationConfigs, { signal }),
+      req(apiRoutes.get_api_conversation_configs.path, s.conversationConfigs, { signal }),
     // One config by its `(target_kind, target_name)` key. 404 when unknown.
     getConversationConfig: (
       targetKind: s.ConversationTargetKind,
@@ -174,7 +200,10 @@ function conversationConfigMethods(t: Transport) {
       signal?: AbortSignal,
     ) =>
       req(
-        `/api/conversation-configs/${encodeSegment(targetKind)}/${encodeSegment(targetName)}`,
+        buildPath(apiRoutes.get_api_conversation_configs_target_kind_target_name.path, {
+          target_kind: targetKind,
+          target_name: targetName,
+        }),
         s.targetConversationConfig,
         { signal },
       ),
@@ -183,14 +212,20 @@ function conversationConfigMethods(t: Transport) {
     // rejects a body whose key disagrees, so both come from the one config object.
     setConversationConfig: (config: s.TargetConversationConfig) =>
       req(
-        `/api/conversation-configs/${encodeSegment(config.target_kind)}/${encodeSegment(config.target_name)}`,
+        buildPath(apiRoutes.put_api_conversation_configs_target_kind_target_name.path, {
+          target_kind: config.target_kind,
+          target_name: config.target_name,
+        }),
         s.conversationConfigWritten,
         { method: 'PUT', body: config },
       ),
     // Delete a config by its key. 404 when the key is unknown.
     deleteConversationConfig: (targetKind: s.ConversationTargetKind, targetName: string) =>
       req(
-        `/api/conversation-configs/${encodeSegment(targetKind)}/${encodeSegment(targetName)}`,
+        buildPath(apiRoutes.delete_api_conversation_configs_target_kind_target_name.path, {
+          target_kind: targetKind,
+          target_name: targetName,
+        }),
         s.conversationConfigDeleted,
         { method: 'DELETE' },
       ),
@@ -204,26 +239,40 @@ function conversationAdminMethods(t: Transport) {
     // Every answer record whose delivery ended `failed`, across every route and
     // caller. Admin-only server-side; not a paged window (returns `{items, total}`).
     listFailedConversationMessages: (signal?: AbortSignal) =>
-      req('/api/conversations/messages/failed', s.conversationFailedMessages, { signal }),
+      req(apiRoutes.get_api_conversations_messages_failed.path, s.conversationFailedMessages, {
+        signal,
+      }),
     // Forget ONE thread on a route (destructive): its checkpoint, answer records and
     // thread indexes. The `thread_id` rides the QUERY value, encoded once — it embeds
     // the api door's percent-encoded `{principal}/{end user}` address, which a path
     // segment would encode a second time. `removed` counts the records this call
     // cleared; a valid id on its own route always succeeds, never a 404.
     deleteConversationThread: (routeName: string, threadId: string) =>
-      req(`/api/conversations/${encodeSegment(routeName)}/thread`, s.conversationThreadDeleted, {
-        method: 'DELETE',
-        query: { thread_id: threadId },
-      }),
+      req(
+        buildPath(apiRoutes.delete_api_conversations_route_name_thread.path, {
+          route_name: routeName,
+        }),
+        s.conversationThreadDeleted,
+        {
+          method: 'DELETE',
+          query: { thread_id: threadId },
+        },
+      ),
     // Erase a LINKED person ENTIRELY (GDPR, wide blast radius): its aggregated thread
     // and checkpoint, its person row, and every address→person index mapping, across
     // EVERY route it wrote under. The `person_id` is a uuid4 with no percent-encoded
     // principal, so it rides the PATH cleanly. `erased` says whether this call removed
     // the person row (idempotent — a retry answers `false`, never a 404).
     deleteConversationPerson: (personId: string) =>
-      req(`/api/conversations/persons/${encodeSegment(personId)}`, s.conversationPersonDeleted, {
-        method: 'DELETE',
-      }),
+      req(
+        buildPath(apiRoutes.delete_api_conversations_persons_person_id.path, {
+          person_id: personId,
+        }),
+        s.conversationPersonDeleted,
+        {
+          method: 'DELETE',
+        },
+      ),
   };
 }
 

package/src/client/hooks-client.ts

@@ -1,5 +1,5 @@
 /** Hook listing, registration and topic-verifier sub-client. */
-import { encodeSegment } from '../http';
+import { apiRoutes, buildPath } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -19,26 +19,39 @@ export function hooksClient(t: Transport) {
   const { req } = t;
   return {
     listHooks: (topic?: string, signal?: AbortSignal) =>
-      req('/api/hooks', s.hookList, { signal, query: topic === undefined ? undefined : { topic } }),
+      req(apiRoutes.get_api_hooks.path, s.hookList, {
+        signal,
+        query: topic === undefined ? undefined : { topic },
+      }),
     registerHook: (params: s.HookRegister) =>
-      req('/api/hooks', s.hookRegistered, { method: 'POST', body: params }),
+      req(apiRoutes.post_api_hooks.path, s.hookRegistered, { method: 'POST', body: params }),
     unregisterHook: (name: string) =>
-      req(`/api/hooks/${encodeSegment(name)}`, s.hookRemoved, { method: 'DELETE' }),
+      req(buildPath(apiRoutes.delete_api_hooks_name.path, { name }), s.hookRemoved, {
+        method: 'DELETE',
+      }),
     // The registered webhook-verifier catalog — the only source the bind picker
     // reads (names only; an empty registry is a valid empty list).
     listHookVerifiers: (signal?: AbortSignal) =>
-      req('/api/hooks/verifiers', s.hookVerifiers, { signal }),
+      req(apiRoutes.get_api_hooks_verifiers.path, s.hookVerifiers, { signal }),
     // Bind a verifier to a topic (locks its otherwise-open public ingress). A PUT
     // replaces any existing binding; an unknown verifier name is a loud 400.
     setTopicVerifier: (topic: string, body: TopicVerifierBody) =>
-      req(`/api/hooks/topics/${encodeSegment(topic)}/verifier`, s.topicVerifierSet, {
-        method: 'PUT',
-        body,
-      }),
+      req(
+        buildPath(apiRoutes.put_api_hooks_topics_topic_verifier.path, { topic }),
+        s.topicVerifierSet,
+        {
+          method: 'PUT',
+          body,
+        },
+      ),
     // Unbind a topic's verifier (re-opens its public ingress). 404 when no binding.
     deleteTopicVerifier: (topic: string) =>
-      req(`/api/hooks/topics/${encodeSegment(topic)}/verifier`, s.topicVerifierRemoved, {
-        method: 'DELETE',
-      }),
+      req(
+        buildPath(apiRoutes.delete_api_hooks_topics_topic_verifier.path, { topic }),
+        s.topicVerifierRemoved,
+        {
+          method: 'DELETE',
+        },
+      ),
   };
 }

package/src/client/index.ts

@@ -1,5 +1,6 @@
 /** Composition root: assembles the per-resource sub-clients into the client. */
 import type { ApiConfig } from '../http';
+import { servedConstants } from '../schemas';
 import { agentsClient } from './agents-client';
 import { authClient } from './auth-client';
 import { backendClient } from './backend-client';
@@ -33,7 +34,6 @@ import { toolMetaClient } from './tool-meta-client';
 import { toolsClient } from './tools-client';
 import { makeTransport } from './transport';
 import { triggerLinksClient } from './trigger-links-client';
-import { webEntryGateClient } from './web-entry-gate-client';
 
 export type {
   AddUrlToScopeBody,
@@ -43,7 +43,12 @@ export type {
   RoleCreateBody,
   RoleUpdateBody,
 } from './auth-client';
-export type { StartConnectArgs } from './connectors-client';
+export type {
+  AddServerArgs,
+  DiscoverServerTarget,
+  SetProviderClientArgs,
+  StartConnectArgs,
+} from './connectors-client';
 export type {
   ConversationMessageSearchQuery,
   ConversationThreadFilters,
@@ -73,12 +78,20 @@ export type { StorageUploadBody } from './storage-client';
 export type { ToolMetaPatch } from './tool-meta-client';
 export type { RunToolArgs, ToolAdminArgs } from './tools-client';
 export type { TriggerLinkCreateBody } from './trigger-links-client';
-export type { WebEntryCodeMintBody } from './web-entry-gate-client';
 
 export function createApiClient(config: ApiConfig) {
   const t = makeTransport(config);
   return {
     baseUrl: config.baseUrl ?? '',
+    /**
+     * The platform constants the contract serves, read instead of re-spelled (`PERSON_KIND`,
+     * `MEDIA_ROUTE_PREFIX`, `MEDIA_ID_PATTERN`).
+     */
+    constants: servedConstants,
+    /** The host's authenticated request for a plugin's own routes: the same auth header,
+     *  401 handling, error classes and `{ data }` unwrap as every core call. Core routes
+     *  use the named methods. */
+    request: t.req,
     ...toolsClient(t),
     ...presetsClient(t),
     ...statesClient(t),
@@ -97,7 +110,6 @@ export function createApiClient(config: ApiConfig) {
     ...interactionsClient(t),
     ...channelsClient(t),
     ...conversationsClient(t),
-    ...webEntryGateClient(t),
     ...notificationsClient(t),
     ...agentsClient(t),
     ...hooksClient(t),

package/src/client/interactions-client.ts

@@ -1,6 +1,8 @@
 /** Interaction listing/answer and the SSE stream sub-clients. */
 import { ApiError, ApiUnauthorizedError } from '../errors';
-import { encodeSegment, extractError } from '../http';
+import { apiRoutes, buildPath } from '../generated/api-routes';
+import { API_KEY_HEADER } from '../headers';
+import { extractError } from '../http';
 import * as s from '../schemas';
 import { readSseFrames, sseOpenToken } from '../sse';
 import type { Transport } from './transport';
@@ -13,24 +15,40 @@ export function interactionsClient(t: Transport) {
     // so `total` is the caller's own count, and every terminal frame it later receives
     // refers to a question within that `total`.
     listInteractions: (page: number, pageSize: number, signal?: AbortSignal) =>
-      req('/api/interactions', s.interactionsPage, { signal, query: { page, pageSize } }),
-    answerInteraction: (interactionId: string, answer: unknown) =>
-      req(`/api/interactions/${encodeSegment(interactionId)}/answer`, s.interactionAnswered, {
-        method: 'POST',
-        body: { answer },
+      req(apiRoutes.get_api_interactions.path, s.interactionsPage, {
+        signal,
+        query: { page, pageSize },
       }),
+    answerInteraction: (interactionId: string, answer: unknown) =>
+      req(
+        buildPath(apiRoutes.post_api_interactions_interaction_id_answer.path, {
+          interaction_id: interactionId,
+        }),
+        s.interactionAnswered,
+        {
+          method: 'POST',
+          body: { answer },
+        },
+      ),
     // React to a still-open form while it is being filled: the in-app, authenticated
     // sibling of the answer door (`POST /api/interactions/{id}/react`). It carries the
     // event that fired (a field changed / a page advanced / the form submitted) and the
-    // partial `values` filled so far, and returns a form update to apply. It is STATELESS
+    // partial `values` filled so far, and returns the form update to apply (the reply's
+    // `update`). It is STATELESS
     // on the server — it records no answer and resolves no interaction — so it never
     // substitutes for the answer door. A handler error/timeout surfaces as the shared
     // `apiRequest` status handling (loud), never a stale value.
     reactInteraction: (interactionId: string, event: s.ReactionEvent, values: unknown) =>
-      req(`/api/interactions/${encodeSegment(interactionId)}/react`, s.formUpdate, {
-        method: 'POST',
-        body: { event, values },
-      }),
+      req(
+        buildPath(apiRoutes.post_api_interactions_interaction_id_react.path, {
+          interaction_id: interactionId,
+        }),
+        s.interactionReaction,
+        {
+          method: 'POST',
+          body: { event, values },
+        },
+      ).then((reply) => reply.update),
     // Withdraw a pending ask WITHOUT answering it (a bodyless POST): the question is
     // resolved as cancelled and the flow that asked never resumes. Terminal like an
     // answer, so the loud failure mappings mirror it — a 409 (already answered, so no
@@ -38,9 +56,15 @@ export function interactionsClient(t: Transport) {
     // and a 403 (not this caller's audience) as `ApiError` — all via the shared
     // `apiRequest` status handling.
     cancelInteraction: (interactionId: string) =>
-      req(`/api/interactions/${encodeSegment(interactionId)}/cancel`, s.interactionCancelled, {
-        method: 'POST',
-      }),
+      req(
+        buildPath(apiRoutes.post_api_interactions_interaction_id_cancel.path, {
+          interaction_id: interactionId,
+        }),
+        s.interactionCancelled,
+        {
+          method: 'POST',
+        },
+      ),
   };
 }
 
@@ -65,11 +89,11 @@ export function interactionsStreamClient(t: Transport) {
       const doFetch = config.fetch ?? globalThis.fetch;
       const token = config.getToken();
       const headers: Record<string, string> = { accept: 'text/event-stream' };
-      if (token) headers['x-api-key'] = token;
+      if (token) headers[API_KEY_HEADER] = token;
       if (lastEventId) headers['last-event-id'] = lastEventId;
       // Distinct-URL per open — see the canonical constraint on `sseOpenToken`.
       const resume = lastEventId ? `&last_event_id=${encodeURIComponent(lastEventId)}` : '';
-      const url = `${config.baseUrl ?? ''}/api/interactions/stream?_=${sseOpenToken()}${resume}`;
+      const url = `${config.baseUrl ?? ''}${apiRoutes.get_api_interactions_stream.path}?_=${sseOpenToken()}${resume}`;
       const response = await doFetch(url, {
         headers,
         signal,

package/src/client/login-client.ts

@@ -5,6 +5,7 @@ import {
   ApiSetupFailedError,
   ApiUnauthorizedError,
 } from '../errors';
+import { apiRoutes } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -79,7 +80,7 @@ export function loginClient(t: Transport) {
     // exists, so the unauthenticated call carries no auth header — no transport
     // change needed.
     getLoginMethods: (options?: { signal?: AbortSignal }) =>
-      req('/api/login/methods', s.loginMethods, { signal: options?.signal }),
+      req(apiRoutes.get_api_login_methods.path, s.loginMethods, { signal: options?.signal }),
     // Submit a `form` method's field VALUES as a flat top-level JSON body (the
     // server's request models take the declared field names top-level). `path`
     // is re-checked with the same relative-`/api/` guard the renderer uses — an
@@ -116,7 +117,10 @@ export function loginClient(t: Transport) {
     // unauthorized redirect. The caller latches the exchange so it fires once.
     claimLogin: async (body: { token: string }) => {
       try {
-        return await req('/api/login/claim', s.loginResult, { method: 'POST', body });
+        return await req(apiRoutes.post_api_login_claim.path, s.loginResult, {
+          method: 'POST',
+          body,
+        });
       } catch (error) {
         return asLoginError(error);
       }
@@ -129,7 +133,7 @@ export function loginClient(t: Transport) {
     // loudly.
     submitSetup: async (body: s.SetupBody) => {
       try {
-        return await req('/api/setup', s.setupResult, { method: 'POST', body });
+        return await req(apiRoutes.post_api_setup.path, s.setupResult, { method: 'POST', body });
       } catch (error) {
         return asSetupError(error);
       }
@@ -145,6 +149,6 @@ export function logoutClient(t: Transport) {
     // has nothing to revoke and answers 404 (surfaced as an `ApiError`, quiet at
     // the call site); a 5xx/network failure is a real revoke failure the shell
     // surfaces loudly.
-    logout: () => req('/api/auth/logout', s.logoutResult, { method: 'POST' }),
+    logout: () => req(apiRoutes.post_api_auth_logout.path, s.logoutResult, { method: 'POST' }),
   };
 }

package/src/client/manifest-client.ts

@@ -1,5 +1,5 @@
 /** Manifest / MCP section, env-ref and config-reload sub-clients. */
-import { encodeSegment } from '../http';
+import { apiRoutes, buildPath } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -31,14 +31,23 @@ export interface SetMcpSecretEnvBody {
 export function manifestClient(t: Transport) {
   const { req } = t;
   return {
-    getManifest: (signal?: AbortSignal) => req('/api/manifest', s.manifestView, { signal }),
+    getManifest: (signal?: AbortSignal) =>
+      req(apiRoutes.get_api_manifest.path, s.manifestView, { signal }),
     setMcpConfig: (mcp: unknown[]) =>
-      req('/api/mcp-config', s.reloadConfigResult, { method: 'POST', body: { mcp } }),
-    getMcpStatus: (signal?: AbortSignal) => req('/api/mcp-status', s.mcpStatus, { signal }),
-    reloadMcp: (title: string) =>
-      req(`/api/mcp-status/${encodeSegment(title)}/reload`, s.mcpReloadResult, {
+      req(apiRoutes.post_api_mcp_config.path, s.reloadConfigResult, {
         method: 'POST',
+        body: { mcp },
       }),
+    getMcpStatus: (signal?: AbortSignal) =>
+      req(apiRoutes.get_api_mcp_status.path, s.mcpStatus, { signal }),
+    reloadMcp: (title: string) =>
+      req(
+        buildPath(apiRoutes.post_api_mcp_status_title_reload.path, { title }),
+        s.mcpReloadResult,
+        {
+          method: 'POST',
+        },
+      ),
 
     // Granular manifest-section entry edits — add/replace or remove ONE entry by
     // title, leaving the rest of the section untouched (the surgical counterpart to
@@ -46,28 +55,36 @@ export function manifestClient(t: Transport) {
     // the shared apply-result (`status` + `env_keys` + fleet `fanout`). `replace` lets
     // an entry whose title already exists swap in; without it a collision is refused.
     addToolsEntries: (entries: readonly unknown[], replace = false) =>
-      req('/api/tools-config/entries', s.reloadConfigResult, {
+      req(apiRoutes.post_api_tools_config_entries.path, s.reloadConfigResult, {
         method: 'POST',
         body: { entries, replace },
       }),
     removeToolsEntry: (title: string) =>
-      req(`/api/tools-config/entries/${encodeSegment(title)}`, s.reloadConfigResult, {
-        method: 'DELETE',
-      }),
+      req(
+        buildPath(apiRoutes.delete_api_tools_config_entries_title.path, { title }),
+        s.reloadConfigResult,
+        {
+          method: 'DELETE',
+        },
+      ),
     addAgentsEntries: (entries: readonly unknown[], replace = false) =>
-      req('/api/agents-config/entries', s.reloadConfigResult, {
+      req(apiRoutes.post_api_agents_config_entries.path, s.reloadConfigResult, {
         method: 'POST',
         body: { entries, replace },
       }),
     removeAgentsEntry: (title: string) =>
-      req(`/api/agents-config/entries/${encodeSegment(title)}`, s.reloadConfigResult, {
-        method: 'DELETE',
-      }),
+      req(
+        buildPath(apiRoutes.delete_api_agents_config_entries_title.path, { title }),
+        s.reloadConfigResult,
+        {
+          method: 'DELETE',
+        },
+      ),
     // Edit the manifest `api_tools` include/exclude name lists by delta (add/remove
     // names on either list). Absent fields default to empty; the server refuses a body
     // whose four lists are all empty. Returns the shared apply-result.
     updateApiTools: (body: ApiToolsListsBody) =>
-      req('/api/api-tools', s.reloadConfigResult, {
+      req(apiRoutes.post_api_api_tools.path, s.reloadConfigResult, {
         method: 'POST',
         body: {
           include_add: body.include_add ?? [],
@@ -83,17 +100,21 @@ export function manifestClient(t: Transport) {
     // every failed server; deregister detaches one server's tools by title. Each op
     // returns the bare per-worker `fleetResult`.
     listFailedMcps: (signal?: AbortSignal) =>
-      req('/api/mcp-status/failed', s.fleetResult, { signal }),
+      req(apiRoutes.get_api_mcp_status_failed.path, s.fleetResult, { signal }),
     reloadFailedMcps: () =>
-      req('/api/mcp-status/reload-failed', s.fleetResult, {
+      req(apiRoutes.post_api_mcp_status_reload_failed.path, s.fleetResult, {
         method: 'POST',
         body: { targets: null },
       }),
     deregisterMcp: (title: string) =>
-      req(`/api/mcp-status/${encodeSegment(title)}/deregister`, s.fleetResult, {
-        method: 'POST',
-        body: { targets: null },
-      }),
+      req(
+        buildPath(apiRoutes.post_api_mcp_status_title_deregister.path, { title }),
+        s.fleetResult,
+        {
+          method: 'POST',
+          body: { targets: null },
+        },
+      ),
   };
 }
 
@@ -103,16 +124,19 @@ export function manifestSecretEnvClient(t: Transport) {
     // The SecretRefField server half: one atomic env-value + `!ENV` manifest
     // write, returning the shared apply-result shape (reload + fleet fanout).
     setMcpSecretEnv: (body: SetMcpSecretEnvBody) =>
-      req('/api/mcp-config/secret-env', s.reloadConfigResult, { method: 'POST', body }),
+      req(apiRoutes.post_api_mcp_config_secret_env.path, s.reloadConfigResult, {
+        method: 'POST',
+        body,
+      }),
     // The PRESERVED manifest (`!ENV` markers intact, no resolved secrets) — the
     // connectors page's McpServersSection reads this so round-trips never inline
     // resolved values.
     getManifestPreserved: (signal?: AbortSignal) =>
-      req('/api/manifest/preserved', s.manifestView, { signal }),
+      req(apiRoutes.get_api_manifest_preserved.path, s.manifestView, { signal }),
     // The manifest MCP section's `!ENV ${VAR[:default]}` marker refs — NAMES and
     // set/unset BOOLEANS only, never values. Drives the McpServersSection env-refs
     // checklist on the connectors page.
     getMcpEnvRefs: (signal?: AbortSignal) =>
-      req('/api/manifest/mcp-env-refs', s.mcpEnvRefs, { signal }),
+      req(apiRoutes.get_api_manifest_mcp_env_refs.path, s.mcpEnvRefs, { signal }),
   };
 }