@tai42/api-client 20.0.0 → 22.0.0

package/src/client/marketplace-client.ts

@@ -1,5 +1,5 @@
 /** Marketplace search, install, update and advisory sub-client. */
-import { encodeSegment } from '../http';
+import { apiRoutes, buildPath } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -70,7 +70,7 @@ export function marketplaceClient(t: Transport) {
     // install/uninstall/update mutate the RUNNING app (pip install + manifest
     // patch + reload) and return synchronous receipts.
     searchMarketplace: (query: MarketplaceSearchQuery = {}, signal?: AbortSignal) =>
-      req('/api/marketplace/search', s.marketplaceSearchPage, {
+      req(apiRoutes.get_api_marketplace_search.path, s.marketplaceSearchPage, {
         query: {
           q: query.q,
           kind: query.kind,
@@ -87,36 +87,47 @@ export function marketplaceClient(t: Transport) {
       }),
     getMarketplacePlugin: (namespace: string, name: string, signal?: AbortSignal) =>
       req(
-        `/api/marketplace/plugins/${encodeSegment(namespace)}/${encodeSegment(name)}`,
+        buildPath(apiRoutes.get_api_marketplace_plugins_ns_name.path, { ns: namespace, name }),
         s.marketplacePluginDetail,
         { signal },
       ),
     listMarketplaceCategories: (signal?: AbortSignal) =>
-      req('/api/marketplace/categories', s.marketplaceCategories, { signal }),
+      req(apiRoutes.get_api_marketplace_categories.path, s.marketplaceCategories, { signal }),
     listMarketplaceKinds: (signal?: AbortSignal) =>
-      req('/api/marketplace/kinds', s.marketplaceKinds, { signal }),
+      req(apiRoutes.get_api_marketplace_kinds.path, s.marketplaceKinds, { signal }),
     listInstalledMarketplacePlugins: (signal?: AbortSignal) =>
-      req('/api/marketplace/installed', s.marketplaceInstalled, { signal }),
+      req(apiRoutes.get_api_marketplace_installed.path, s.marketplaceInstalled, { signal }),
     // Preview resolves the spec and computes routes/collisions/public rows with
     // NO side effects, so the install dialog can show absolute paths, block on a
     // collision, and surface the public routes before the operator commits.
     previewMarketplaceInstall: (body: MarketplaceInstallPreviewBody, signal?: AbortSignal) =>
-      req('/api/marketplace/install/preview', s.marketplaceInstallPreview, {
+      req(apiRoutes.post_api_marketplace_install_preview.path, s.marketplaceInstallPreview, {
         method: 'POST',
         body,
         signal,
       }),
     installMarketplacePlugin: (body: MarketplaceInstallBody) =>
-      req('/api/marketplace/install', s.marketplaceInstallResult, { method: 'POST', body }),
+      req(apiRoutes.post_api_marketplace_install.path, s.marketplaceInstallResult, {
+        method: 'POST',
+        body,
+      }),
     uninstallMarketplacePlugin: (body: MarketplaceUninstallBody) =>
-      req('/api/marketplace/uninstall', s.marketplaceUninstallResult, { method: 'POST', body }),
+      req(apiRoutes.post_api_marketplace_uninstall.path, s.marketplaceUninstallResult, {
+        method: 'POST',
+        body,
+      }),
     updateMarketplacePlugin: (body: MarketplaceInstallBody) =>
-      req('/api/marketplace/update', s.marketplaceInstallResult, { method: 'POST', body }),
+      req(apiRoutes.post_api_marketplace_update.path, s.marketplaceInstallResult, {
+        method: 'POST',
+        body,
+      }),
     // Upgrade EVERY installed plugin to its newest compatible version in one
     // pass; the response is the per-plugin outcome readout.
     upgradeAllMarketplacePlugins: () =>
-      req('/api/marketplace/upgrade-all', s.marketplaceUpgradeAllResult, { method: 'POST' }),
+      req(apiRoutes.post_api_marketplace_upgrade_all.path, s.marketplaceUpgradeAllResult, {
+        method: 'POST',
+      }),
     getMarketplaceAdvisories: (signal?: AbortSignal) =>
-      req('/api/marketplace/advisories', s.marketplaceAdvisories, { signal }),
+      req(apiRoutes.get_api_marketplace_advisories.path, s.marketplaceAdvisories, { signal }),
   };
 }

package/src/client/mcp-config-schema-client.ts

@@ -1,4 +1,5 @@
 /** MCP config-schema read sub-client. */
+import { apiRoutes } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -6,6 +7,6 @@ export function mcpConfigSchemaClient(t: Transport) {
   const { req } = t;
   return {
     getMcpConfigSchema: (signal?: AbortSignal) =>
-      req('/api/mcp-config/schema', s.jsonSchema, { signal }),
+      req(apiRoutes.get_api_mcp_config_schema.path, s.jsonSchema, { signal }),
   };
 }

package/src/client/notifications-client.ts

@@ -1,4 +1,5 @@
 /** Notification-sink listing sub-client. */
+import { apiRoutes } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -8,6 +9,6 @@ export function notificationsClient(t: Transport) {
     // The internal notifications sink, newest-first — the messages the `notify_user`
     // operation records with no channel, so they surface only in this inbox.
     listNotifications: (signal?: AbortSignal) =>
-      req('/api/notifications', s.notifications, { signal }),
+      req(apiRoutes.get_api_notifications.path, s.notifications, { signal }),
   };
 }

package/src/client/observability-client.ts

@@ -1,5 +1,6 @@
 /** Run metrics, listing, trace and export sub-client. */
-import { apiDownload, encodeSegment, type RequestOptions } from '../http';
+import { apiRoutes, buildPath } from '../generated/api-routes';
+import { apiDownload, type RequestOptions } from '../http';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -58,23 +59,74 @@ export function observabilityClient(t: Transport) {
     // The monitoring-backend dashboard rollups (`GET /api/observability/metrics`),
     // a JSON aggregate distinct from any raw process-metrics text endpoint.
     getObservabilityMetrics: (params: MetricsQuery = {}, signal?: AbortSignal) =>
-      req('/api/observability/metrics', s.dashboardMetrics, {
+      req(apiRoutes.get_api_observability_metrics.path, s.dashboardMetrics, {
         query: { from: params.from, to: params.to, granularity: params.granularity },
         signal,
       }),
     listRuns: (params: RunsQuery = {}, signal?: AbortSignal) =>
-      req('/api/observability/runs', s.runsPage, { query: runsQueryToParams(params), signal }),
-    getRunTrace: (traceId: string, signal?: AbortSignal) =>
-      req(`/api/observability/runs/${encodeSegment(traceId)}/trace`, s.runTrace, { signal }),
-    exportTrace: (traceId: string, signal?: AbortSignal): Promise<Blob> =>
-      apiDownload(config, `/api/observability/runs/${encodeSegment(traceId)}/trace/export`, {
+      req(apiRoutes.get_api_observability_runs.path, s.runsPage, {
+        query: runsQueryToParams(params),
+        signal,
+      }),
+    // What the monitoring backend serves: page ceiling, sorts, sort/filter combinations, metrics.
+    getObservabilityCapabilities: (signal?: AbortSignal) =>
+      req(apiRoutes.get_api_observability_capabilities.path, s.observabilityCapabilities, {
         signal,
       }),
+    getRunTrace: (traceId: string, signal?: AbortSignal) =>
+      req(
+        buildPath(apiRoutes.get_api_observability_runs_trace_id_trace.path, { trace_id: traceId }),
+        s.runTrace,
+        { signal },
+      ),
+    // The run's span tree without span inputs/outputs.
+    getRunTraceOutline: (traceId: string, signal?: AbortSignal) =>
+      req(
+        buildPath(apiRoutes.get_api_observability_runs_trace_id_trace_outline.path, {
+          trace_id: traceId,
+        }),
+        s.runTraceOutline,
+        {
+          signal,
+        },
+      ),
+    // One span field with every record reference resolved; `pointer` is an RFC 6901
+    // JSON pointer into the field's value (omitted or empty = the whole value).
+    getResolvedSpanValue: (
+      traceId: string,
+      spanId: string,
+      field: 'input' | 'output',
+      options: { readonly pointer?: string } = {},
+      signal?: AbortSignal,
+    ) =>
+      req(
+        buildPath(apiRoutes.get_api_observability_runs_trace_id_spans_span_id_resolved.path, {
+          trace_id: traceId,
+          span_id: spanId,
+        }),
+        s.resolvedSpanValue,
+        { query: { field, pointer: options.pointer === '' ? undefined : options.pointer }, signal },
+      ),
+    exportTrace: (
+      traceId: string,
+      options: { readonly resolve?: boolean } = {},
+      signal?: AbortSignal,
+    ): Promise<Blob> =>
+      apiDownload(
+        config,
+        buildPath(apiRoutes.get_api_observability_runs_trace_id_trace_export.path, {
+          trace_id: traceId,
+        }),
+        {
+          query: { resolve: options.resolve ? 'true' : undefined },
+          signal,
+        },
+      ),
     exportRuns: (
       params: RunsQuery & { format: 'csv' | 'json' },
       signal?: AbortSignal,
     ): Promise<Blob> =>
-      apiDownload(config, '/api/observability/runs/export', {
+      apiDownload(config, apiRoutes.get_api_observability_runs_export.path, {
         query: { ...runsQueryToParams(params), format: params.format },
         signal,
       }),

package/src/client/plugins-client.ts

@@ -1,4 +1,5 @@
 /** Studio front-end plugin registry sub-client. */
+import { apiRoutes } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -6,6 +7,6 @@ export function pluginsClient(t: Transport) {
   const { req } = t;
   return {
     listStudioPlugins: (signal?: AbortSignal) =>
-      req('/api/plugins', s.studioPluginRegistry, { signal }),
+      req(apiRoutes.get_api_plugins.path, s.studioPluginRegistry, { signal }),
   };
 }

package/src/client/policy-client.ts

@@ -1,5 +1,5 @@
 /** Access-policy validation, versioning and rollback sub-client. */
-import { encodeSegment } from '../http';
+import { apiRoutes, buildPath } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -22,20 +22,35 @@ export function policyClient(t: Transport) {
     // author time instead of locking a key out at enforcement. A broken condition
     // is a 400 the transport throws — never a false-positive `ok`.
     validateCondition: (body: ValidateConditionBody) =>
-      req('/api/auth/validate-condition', s.validateConditionResult, { method: 'POST', body }),
+      req(apiRoutes.post_api_auth_validate_condition.path, s.validateConditionResult, {
+        method: 'POST',
+        body,
+      }),
     // The user's append-only policy version history (each row's `is_current`
     // derived from the active pointer). SECRET-ADJACENT — the body carries the raw
     // condition, so its fixtures are hand-authored.
     listPolicyVersions: (userId: string, signal?: AbortSignal) =>
-      req(`/api/auth/api-keys/${encodeSegment(userId)}/policy/versions`, s.policyVersionList, {
-        signal,
-      }),
+      req(
+        buildPath(apiRoutes.get_api_auth_api_keys_user_id_policy_versions.path, {
+          user_id: userId,
+        }),
+        s.policyVersionList,
+        {
+          signal,
+        },
+      ),
     // Re-point the enforced policy to a prior version; returns the re-pointed
     // active version. Enforcement follows on cache invalidation.
     rollbackPolicy: (userId: string, version: number) =>
-      req(`/api/auth/api-keys/${encodeSegment(userId)}/policy/rollback`, s.policyRollback, {
-        method: 'POST',
-        body: { version },
-      }),
+      req(
+        buildPath(apiRoutes.post_api_auth_api_keys_user_id_policy_rollback.path, {
+          user_id: userId,
+        }),
+        s.policyRollback,
+        {
+          method: 'POST',
+          body: { version },
+        },
+      ),
   };
 }

package/src/client/presets-client.ts

@@ -1,5 +1,5 @@
 /** Preset CRUD, versioning and validation sub-client. */
-import { encodeSegment } from '../http';
+import { apiRoutes, buildPath } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -74,49 +74,62 @@ export function presetsClient(t: Transport) {
   return {
     // Every preset is store-backed and versioned; the list is the single
     // management population (the presets plus the conflicted quarantined rows).
-    listPresets: (signal?: AbortSignal) => req('/api/presets', s.presetList, { signal }),
+    listPresets: (signal?: AbortSignal) =>
+      req(apiRoutes.get_api_presets.path, s.presetList, { signal }),
     createPreset: (body: CreatePresetBody) =>
-      req('/api/presets', s.presetRecord, { method: 'POST', body }),
+      req(apiRoutes.post_api_presets.path, s.presetRecord, { method: 'POST', body }),
     getPreset: (name: string, signal?: AbortSignal) =>
-      req(`/api/presets/${encodeSegment(name)}`, s.presetDetail, { signal }),
+      req(buildPath(apiRoutes.get_api_presets_name.path, { name }), s.presetDetail, { signal }),
     listPresetVersions: (name: string, signal?: AbortSignal) =>
-      req(`/api/presets/${encodeSegment(name)}/versions`, s.presetVersionList, { signal }),
+      req(buildPath(apiRoutes.get_api_presets_name_versions.path, { name }), s.presetVersionList, {
+        signal,
+      }),
     getPresetVersion: (name: string, version: number, signal?: AbortSignal) =>
       req(
-        `/api/presets/${encodeSegment(name)}/versions/${encodeSegment(version)}`,
+        buildPath(apiRoutes.get_api_presets_name_versions_version.path, {
+          name,
+          version: String(version),
+        }),
         s.presetVersion,
         { signal },
       ),
     savePresetVersion: (name: string, body: SavePresetVersionBody) =>
-      req(`/api/presets/${encodeSegment(name)}/versions`, s.presetVersion, {
+      req(buildPath(apiRoutes.post_api_presets_name_versions.path, { name }), s.presetVersion, {
         method: 'POST',
         body,
       }),
     rollbackPreset: (name: string, version: number) =>
-      req(`/api/presets/${encodeSegment(name)}/rollback`, s.presetRollback, {
+      req(buildPath(apiRoutes.post_api_presets_name_rollback.path, { name }), s.presetRollback, {
         method: 'POST',
         body: { version },
       }),
     deletePreset: (name: string) =>
-      req(`/api/presets/${encodeSegment(name)}`, s.presetDeleted, { method: 'DELETE' }),
+      req(buildPath(apiRoutes.delete_api_presets_name.path, { name }), s.presetDeleted, {
+        method: 'DELETE',
+      }),
     renamePreset: (name: string, newName: string) =>
-      req(`/api/presets/${encodeSegment(name)}/rename`, s.presetRenamed, {
+      req(buildPath(apiRoutes.post_api_presets_name_rename.path, { name }), s.presetRenamed, {
         method: 'POST',
         body: { new_name: newName },
       }),
     // The presets whose active composition names this one as a tool — the referees
     // a rename would strand. A rename preflight reads this to warn before the 409.
     getPresetReferees: (name: string, signal?: AbortSignal) =>
-      req(`/api/presets/${encodeSegment(name)}/referees`, s.presetReferees, { signal }),
+      req(buildPath(apiRoutes.get_api_presets_name_referees.path, { name }), s.presetReferees, {
+        signal,
+      }),
     // The dry-run verdict for a draft (create OR version, mode-resolved server-side):
     // `valid` plus the server's verbatim `error` message. Both verdicts are HTTP 200.
     validatePreset: (body: ValidatePresetBody) =>
-      req('/api/presets/validate', s.presetValidation, { method: 'POST', body }),
+      req(apiRoutes.post_api_presets_validate.path, s.presetValidation, { method: 'POST', body }),
     // Replace one version's `tags` annotation — labels on an immutable body, so no
     // rebind. Returns the re-annotated identity + new tag list.
     setPresetVersionTags: (name: string, version: number, tags: readonly string[]) =>
       req(
-        `/api/presets/${encodeSegment(name)}/versions/${encodeSegment(version)}/tags`,
+        buildPath(apiRoutes.put_api_presets_name_versions_version_tags.path, {
+          name,
+          version: String(version),
+        }),
         s.presetVersionTags,
         { method: 'PUT', body: { tags } },
       ),

package/src/client/profiles-client.ts

@@ -1,5 +1,5 @@
 /** Settings-profile CRUD, versioning and apply sub-client. */
-import { encodeSegment } from '../http';
+import { apiRoutes, buildPath } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -9,43 +9,72 @@ export function profilesClient(t: Transport) {
     // The admin-only `/api/config/profiles/*` surface. Bodies/diff/versions carry
     // REAL secret values (secret/fenced routes); masking is CLIENT-SIDE.
     listSettingsProfiles: (signal?: AbortSignal) =>
-      req('/api/config/profiles', s.settingsProfileList, { signal }),
+      req(apiRoutes.get_api_config_profiles.path, s.settingsProfileList, { signal }),
     getSettingsProfile: (name: string, signal?: AbortSignal) =>
-      req(`/api/config/profiles/${encodeSegment(name)}`, s.settingsProfileBody, { signal }),
-    putSettingsProfile: (name: string, body: s.SettingsProfileBody) =>
-      req(`/api/config/profiles/${encodeSegment(name)}`, s.settingsProfileSaved, {
-        method: 'PUT',
-        body,
+      req(buildPath(apiRoutes.get_api_config_profiles_name.path, { name }), s.settingsProfileBody, {
+        signal,
       }),
+    putSettingsProfile: (name: string, body: s.SettingsProfileBody) =>
+      req(
+        buildPath(apiRoutes.put_api_config_profiles_name.path, { name }),
+        s.settingsProfileSaved,
+        {
+          method: 'PUT',
+          body,
+        },
+      ),
     deleteSettingsProfile: (name: string) =>
-      req(`/api/config/profiles/${encodeSegment(name)}`, s.settingsProfileDeleted, {
-        method: 'DELETE',
-      }),
+      req(
+        buildPath(apiRoutes.delete_api_config_profiles_name.path, { name }),
+        s.settingsProfileDeleted,
+        {
+          method: 'DELETE',
+        },
+      ),
     // Diff of the SAVED profile vs the stored env — server-computed, no request body.
     diffSettingsProfile: (name: string) =>
-      req(`/api/config/profiles/${encodeSegment(name)}/diff`, s.settingsProfileDiff, {
-        method: 'POST',
-      }),
+      req(
+        buildPath(apiRoutes.post_api_config_profiles_name_diff.path, { name }),
+        s.settingsProfileDiff,
+        {
+          method: 'POST',
+        },
+      ),
     // Apply the SAVED profile (full-replace of the profile-managed band). Fenced,
     // destructive → the dedicated `profile_apply_response` report.
     applySettingsProfile: (name: string) =>
-      req(`/api/config/profiles/${encodeSegment(name)}/apply`, s.profileApplyResponse, {
-        method: 'POST',
-      }),
+      req(
+        buildPath(apiRoutes.post_api_config_profiles_name_apply.path, { name }),
+        s.profileApplyResponse,
+        {
+          method: 'POST',
+        },
+      ),
     listSettingsProfileVersions: (name: string, signal?: AbortSignal) =>
-      req(`/api/config/profiles/${encodeSegment(name)}/versions`, s.settingsProfileVersionList, {
-        signal,
-      }),
+      req(
+        buildPath(apiRoutes.get_api_config_profiles_name_versions.path, { name }),
+        s.settingsProfileVersionList,
+        {
+          signal,
+        },
+      ),
     getSettingsProfileVersion: (name: string, version: number, signal?: AbortSignal) =>
       req(
-        `/api/config/profiles/${encodeSegment(name)}/versions/${encodeSegment(version)}`,
+        buildPath(apiRoutes.get_api_config_profiles_name_versions_version.path, {
+          name,
+          version: String(version),
+        }),
         s.settingsProfileVersion,
         { signal },
       ),
     rollbackSettingsProfile: (name: string, version: number) =>
-      req(`/api/config/profiles/${encodeSegment(name)}/rollback`, s.settingsProfileRollback, {
-        method: 'POST',
-        body: { version },
-      }),
+      req(
+        buildPath(apiRoutes.post_api_config_profiles_name_rollback.path, { name }),
+        s.settingsProfileRollback,
+        {
+          method: 'POST',
+          body: { version },
+        },
+      ),
   };
 }

package/src/client/schedules-client.ts

@@ -1,31 +1,25 @@
 /** Schedule listing and mutation sub-client. */
-import { encodeSegment } from '../http';
+import { apiRoutes, buildPath } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
 export function schedulesClient(t: Transport) {
   const { req } = t;
   return {
-    listSchedules: (signal?: AbortSignal) => req('/api/schedules', s.scheduleList, { signal }),
+    listSchedules: (signal?: AbortSignal) =>
+      req(apiRoutes.get_api_schedules.path, s.scheduleList, { signal }),
     getServerDateTime: (signal?: AbortSignal) =>
-      req('/api/schedules/server-datetime', s.serverDateTime, { signal }),
-    addSchedule: (body: {
-      tool_name: string;
-      tool_kwargs: Record<string, unknown>;
-      schedule_kwargs: Record<string, unknown>;
-      // The api-key user_id a contract-bearing recurring fire runs as; required with any door jq.
-      execution_key?: string | null;
-      // The optional door-layer state binding applied around every fire of this schedule.
-      state_binding?: s.StateBinding | null;
-      // The optional door-contract jqs a parkable-driving schedule carries: start_expr
-      // builds the fired tool's kwargs, cancel/resume act on parked interactions, extras
-      // builds the started run's extras.
-      start_expr?: s.TemplatedText | null;
-      cancel_expr?: s.TemplatedText | null;
-      resume_expr?: s.TemplatedText | null;
-      extras_expr?: s.TemplatedText | null;
-    }) => req('/api/schedules', s.jsonValue, { method: 'POST', body }),
+      req(apiRoutes.get_api_schedules_server_datetime.path, s.serverDateTime, { signal }),
+    // The body is the served `ScheduleCreate` document: the base tool, its kwargs, an optional
+    // typed cadence (none runs the tool once now) and schedule name, the top-level subject,
+    // the state binding, the execution key and the four door-contract jqs.
+    addSchedule: (body: s.ScheduleCreate) =>
+      req(apiRoutes.post_api_schedules.path, s.jsonValue, { method: 'POST', body }),
     deleteSchedule: (name: string) =>
-      req(`/api/schedules/${encodeSegment(name)}`, s.jsonValue, { method: 'DELETE' }),
+      req(
+        buildPath(apiRoutes.delete_api_schedules_schedule_name.path, { schedule_name: name }),
+        s.jsonValue,
+        { method: 'DELETE' },
+      ),
   };
 }

package/src/client/settings-schema-client.ts

@@ -1,4 +1,5 @@
 /** Settings-form schema read sub-client. */
+import { apiRoutes } from '../generated/api-routes';
 import * as s from '../schemas';
 import type { Transport } from './transport';
 
@@ -6,6 +7,6 @@ export function settingsSchemaClient(t: Transport) {
   const { req } = t;
   return {
     getSettingsSchema: (signal?: AbortSignal) =>
-      req('/api/config/settings-schema', s.settingsSchema, { signal }),
+      req(apiRoutes.get_api_config_settings_schema.path, s.settingsSchema, { signal }),
   };
 }