@tai42/api-client 19.3.0 → 21.0.0

package/src/schemas/connectors.ts

@@ -1,37 +1,14 @@
 /** Connector provider catalog and connection lifecycle schemas. */
 import { z } from 'zod';
 
+import * as openapi from '../generated/openapi-schemas';
 import { fleetReportFanout } from './fleet';
 
-export const subServiceView = z.object({
-  id: z.string(),
-  display_name: z.string(),
-  description: z.string(),
-  scopes: z.array(z.string()),
-});
+export const subServiceView = openapi.subServiceView;
 
-export const configFieldView = z.object({
-  key: z.string(),
-  label: z.string(),
-  target: z.enum(['env', 'header']),
-  required: z.boolean(),
-  secret: z.boolean(),
-});
+export const configFieldView = openapi.configFieldSpec;
 
-export const providerView = z.object({
-  id: z.string(),
-  display_name: z.string(),
-  description: z.string(),
-  // Required and a real URL: the contract's `ProviderDescriptor.icon_url` runs
-  // `check_web_url(schemes=("https",))`, which rejects an empty/relative value, so
-  // an empty or malformed one here is drift and fails the parse loudly.
-  icon_url: z.url(),
-  kind: z.enum(['oauth', 'none']),
-  origin: z.enum(['system', 'community']),
-  category: z.string(),
-  sub_services: z.array(subServiceView),
-  config_fields: z.array(configFieldView),
-});
+export const providerView = openapi.providerCatalogEntry;
 export type ProviderView = z.infer<typeof providerView>;
 
 /**
@@ -39,101 +16,83 @@ export type ProviderView = z.infer<typeof providerView>;
  * label and sort key for the providers it groups, so the list can group, order,
  * and label providers by category without a second read.
  */
-export const connectorCategoryView = z.object({
-  id: z.string(),
-  display_name: z.string(),
-  sort_order: z.number(),
-});
+export const connectorCategoryView = openapi.connectorCategoryView;
 export type ConnectorCategoryView = z.infer<typeof connectorCategoryView>;
 
 /**
  * `GET /api/connectors/providers` — the provider catalog: the providers plus the
- * category groupings the UI arranges them under. Reshaped from a bare provider
- * array so the category label/order surface rides the same read.
+ * category groupings the UI arranges them under.
  */
-export const providers = z.object({
-  providers: z.array(providerView),
-  categories: z.array(connectorCategoryView),
-});
+export const providers = openapi.providerCatalogResponse;
 export type ProviderCatalogResponse = z.infer<typeof providers>;
 
-export const connectionView = z.object({
-  connection_id: z.string(),
-  provider_id: z.string(),
-  alias: z.string(),
-  kind: z.enum(['oauth', 'none']),
-  account_identity: z.string().nullable(),
-  enabled_sub_services: z.array(z.string()),
-  granted_scopes: z.array(z.string()),
-  // Sub-services whose MCP server did not answer a live reachability probe.
-  // Populated only on the single-connection GET (the list projection is
-  // probe-free and always sends `[]`). Reachability is distinct from
-  // `auth_health_state`: a healthy connection can still have a down sub-service.
-  // Defaulted so a projection that omits it (an older worker mid-rollout) still
-  // parses rather than false-failing the whole view.
-  unreachable_sub_services: z.array(z.string()).default([]),
-  auth_health_state: z.enum(['healthy', 'reconnect_required', 'refresh_failing']),
-  created_at: z.string(),
-});
+/**
+ * One connection. `unreachable_sub_services` names the sub-services whose MCP server did
+ * not answer a live reachability probe: populated only on the single-connection GET (the
+ * list projection is probe-free and always sends `[]`). Reachability is distinct from
+ * `auth_health_state`: a healthy connection can still have a down sub-service.
+ */
+export const connectionView = openapi.connectedAccountView;
 export type ConnectionView = z.infer<typeof connectionView>;
 
-export const connectionsList = z.object({
-  items: z.array(connectionView),
-  total: z.number(),
-  // Count of connections whose `auth_health_state` is not healthy across the whole
-  // set (independent of any filter/limit) — the attention-badge count. Optional:
-  // no UI consumes it, and an older worker mid-rollout omits it.
-  unhealthy: z.number().optional(),
-});
+/**
+ * The connections listing. `unhealthy` counts the connections whose `auth_health_state`
+ * is not healthy across the whole set (independent of any filter/limit).
+ */
+export const connectionsList = openapi.connectionsListResponse;
 
-// A connector mutation that writes the manifest embeds the mode-wrapped fleet
-// `fanout` of the reload it broadcast; it is `null` when the response path mutated no
-// manifest (an OAuth START opens a flow before any write). Parsed EXPLICITLY so the
-// shared fleet-report handler surfaces a failed propagation on every connector flow —
-// zod's unknown-key stripping would otherwise drop it silently.
+// A connector mutation that writes the manifest embeds the mode-wrapped fleet `fanout` of
+// the reload it broadcast; it is `null` when the response path mutated no manifest (an
+// OAuth START opens a flow before any write). Hand-typed: the spec publishes the fan-out as
+// an open object; the client discriminates its modes so the shared fleet-report handler
+// surfaces a failed propagation on every connector flow.
 export const startConnectResult = z.union([
-  z.object({ flow_id: z.string(), authorize_url: z.string() }),
-  z.object({
-    connection_id: z.string(),
-    added_manifest_entries: z.array(z.string()),
-    fanout: fleetReportFanout.nullable(),
-  }),
+  openapi.startConnectResponse,
+  openapi.startConnectNoAuthResponse.extend({ fanout: fleetReportFanout.nullable().default(null) }),
 ]);
 
 // A reconnect START opens an OAuth flow and writes no manifest, so it carries no
 // fan-out (the manifest write lands when the flow completes).
-export const reconnectResult = z.object({ flow_id: z.string(), authorize_url: z.string() });
-
-export const disconnectResult = z.object({
-  connection_id: z.string(),
-  upstream_revoke_outcome: z.enum(['success', 'failed', 'skipped']),
-  upstream_revoke_status: z.number().nullable(),
-  removed_manifest_entries: z.array(z.string()),
-  fanout: fleetReportFanout.nullable(),
+export const reconnectResult = openapi.startConnectResponse;
+
+export const disconnectResult = openapi.disconnectResponse.extend({
+  fanout: fleetReportFanout.nullable().default(null),
 });
 
-export const patchSubServicesResult = z.object({
-  connection_id: z.string(),
-  enabled_sub_services: z.array(z.string()),
-  consent_required: z.boolean(),
-  flow_id: z.string().nullable(),
-  authorize_url: z.string().nullable(),
-  added_manifest_entries: z.array(z.string()),
-  removed_manifest_entries: z.array(z.string()),
+export const patchSubServicesResult = openapi.patchSubServicesResponse.extend({
   // `null` on a consent-only toggle that forks an OAuth flow without a manifest write.
-  fanout: fleetReportFanout.nullable(),
+  fanout: fleetReportFanout.nullable().default(null),
 });
 
 export const oauthCompleteResult = z.discriminatedUnion('kind', [
-  z.object({
-    kind: z.literal('success'),
-    connection_id: z.string(),
-    return_url: z.string(),
-    // `null` when completing the flow mutated no manifest (a reconcile that changed
-    // nothing).
-    fanout: fleetReportFanout.nullable(),
-  }),
-  z.object({ kind: z.literal('failed'), reason: z.string() }),
-  z.object({ kind: z.literal('cancelled'), message: z.string() }),
+  openapi.oAuthNotConfigured,
+  openapi.oAuthCancelled,
+  openapi.oAuthFailed,
+  openapi.oAuthSuccess.extend({ fanout: fleetReportFanout }),
 ]);
 export type OAuthCompleteResult = z.infer<typeof oauthCompleteResult>;
+
+/**
+ * `POST /api/connectors/providers/discover` — what a look-up found: the server's
+ * protected resource, the sign-in services it lists, and whether a login started from
+ * this deployment needs client credentials from anyone.
+ */
+export const discoveredServer = openapi.discoveredServerView;
+export type DiscoveredServer = z.infer<typeof discoveredServer>;
+
+/**
+ * `POST /api/connectors/providers` and `PUT /api/connectors/providers/{id}/client` —
+ * the provider's catalog entry after the change, and the fleet report of the manifest
+ * write it made (`null` when none was made). The fan-out is hand-typed (the spec publishes it
+ * as an open object) so the shared fleet-report handler can surface a failed propagation.
+ */
+export const providerMutationResult = openapi.providerMutationResponse.extend({
+  fanout: fleetReportFanout.nullable().default(null),
+});
+export type ProviderMutationResult = z.infer<typeof providerMutationResult>;
+
+/** `DELETE /api/connectors/providers/{id}` — the removed provider and its manifest write. */
+export const removeProviderResult = openapi.removeProviderResponse.extend({
+  fanout: fleetReportFanout.nullable().default(null),
+});
+export type RemoveProviderResult = z.infer<typeof removeProviderResult>;

package/src/schemas/conversations.ts

@@ -1,22 +1,22 @@
 /** Conversation route, thread, transcript and config schemas. */
-import { z } from 'zod';
+import type { z } from 'zod';
 
-import { conversationRoute, targetConversationConfig } from './served';
-import { pageWindow } from './shared';
+import * as openapi from '../generated/openapi-schemas';
 
 // The cross-channel conversation monitor's READ side: the stored routing rows
 // (the route picker) from `GET /api/conversations`, a route's threads from
 // `GET /api/conversations/{route}/threads`, and one thread's transcript from
 // `GET /api/conversations/{route}/transcript?thread_id=`. Timestamps are float
 // epoch seconds, not ISO strings, and both paged doors carry the same window
-// fields; the transcript adds the direction it was read in.
+// fields; the transcript adds the direction it was read in. Each listing reports
+// `unreadable`, the stored rows it could not read.
 
 /** The inbound door a route is bound to: the authed API, or a channel medium. */
-export const conversationDoor = z.enum(['api', 'channel']);
+export const conversationDoor = openapi.conversationRecordView.shape.door;
 export type ConversationDoor = z.infer<typeof conversationDoor>;
 
 /** What a route's turn runs: a registered agent, or a tool dispatch. */
-export const conversationTargetKind = z.enum(['agent', 'tool']);
+export const conversationTargetKind = openapi.conversationConfigSetResult.shape.target_kind;
 export type ConversationTargetKind = z.infer<typeof conversationTargetKind>;
 
 /**
@@ -25,7 +25,7 @@ export type ConversationTargetKind = z.infer<typeof conversationTargetKind>;
  * operator to answer. The same value vocabulary as a per-thread mode override, but
  * a distinct concept (the route default vs. one thread's override).
  */
-export const conversationMode = z.enum(['agent', 'manual']);
+export const conversationMode = openapi.threadModeView.shape.mode;
 export type ConversationMode = z.infer<typeof conversationMode>;
 
 /**
@@ -35,27 +35,13 @@ export type ConversationMode = z.infer<typeof conversationMode>;
  * record's text was carried into (`merged`) or dropped in favour of (`superseded`)
  * a later turn, named by `successor_id`; both are terminal and never send.
  */
-export const conversationDeliveryStatus = z.enum([
-  'accepted',
-  'pending_delivery',
-  'provisional',
-  'delivered',
-  'failed',
-  'shed',
-  'silent',
-  'merged',
-  'superseded',
-]);
+export const conversationDeliveryStatus = openapi.deliveryStatus;
 export type ConversationDeliveryStatus = z.infer<typeof conversationDeliveryStatus>;
 
 /** The nature of a turn's outcome, orthogonal to where its delivery stands. */
-export const conversationAnswerStatus = z.enum([
-  'answered',
-  'error',
-  'silent',
-  'merged',
-  'superseded',
-]);
+export const conversationAnswerStatus = openapi.conversationRecordView.shape.answer_status
+  .unwrap()
+  .unwrap();
 export type ConversationAnswerStatus = z.infer<typeof conversationAnswerStatus>;
 
 /**
@@ -63,13 +49,14 @@ export type ConversationAnswerStatus = z.infer<typeof conversationAnswerStatus>;
  * answered; `operator` is a message a human sent into the thread, whose text
  * rides `answer` (its `inbound_text` is empty).
  */
-export const conversationRecordOrigin = z.enum(['client', 'operator']);
+export const conversationRecordOrigin = openapi.conversationRecordView.shape.origin;
 export type ConversationRecordOrigin = z.infer<typeof conversationRecordOrigin>;
 
-export const conversationRoutes = z.object({
-  items: z.array(conversationRoute),
-  total: z.number(),
-});
+/** One stored routing row as a read door serves it, its `callback_secret` withheld. */
+export const conversationRouteView = openapi.conversationRouteViewBody;
+export type ConversationRouteView = z.infer<typeof conversationRouteView>;
+
+export const conversationRoutes = openapi.conversationRouteListEnvelope;
 export type ConversationRoutes = z.infer<typeof conversationRoutes>;
 
 /**
@@ -79,12 +66,7 @@ export type ConversationRoutes = z.infer<typeof conversationRoutes>;
  * row). The secret signs delivery callbacks and is never re-read from any door, so
  * a caller that needs it must capture it from this reply.
  */
-export const conversationRouteWritten = z.object({
-  created: z.boolean(),
-  route_name: z.string(),
-  route: conversationRoute,
-  callback_secret: z.string().nullable(),
-});
+export const conversationRouteWritten = openapi.conversationRouteCreateResult;
 export type ConversationRouteWritten = z.infer<typeof conversationRouteWritten>;
 
 /**
@@ -92,10 +74,7 @@ export type ConversationRouteWritten = z.infer<typeof conversationRouteWritten>;
  * retryable reclamation of orphaned thread indexes answers `false` rather than a
  * 404).
  */
-export const conversationRouteDeleted = z.object({
-  removed: z.boolean(),
-  route_name: z.string(),
-});
+export const conversationRouteDeleted = openapi.routeRemoveResult;
 export type ConversationRouteDeleted = z.infer<typeof conversationRouteDeleted>;
 
 /**
@@ -104,58 +83,22 @@ export type ConversationRouteDeleted = z.infer<typeof conversationRouteDeleted>;
  * goes back into a URL as a path segment — the transcript door takes it as a
  * query value.
  */
-export const conversationThread = z.object({
-  thread_id: z.string(),
-  client_address: z.string(),
-  last_activity_at: z.number(),
-  message_count: z.number(),
-  last_delivery_status: conversationDeliveryStatus,
-});
+export const conversationThread = openapi.threadSummaryRow;
 export type ConversationThread = z.infer<typeof conversationThread>;
 
-export const conversationThreadsPage = z.object({
-  items: z.array(conversationThread),
-  ...pageWindow,
-});
+export const conversationThreadsPage = openapi.threadSummaryEnvelope;
 export type ConversationThreadsPage = z.infer<typeof conversationThreadsPage>;
 
 /**
  * One exchange: the visitor's `inbound_text` — every record answers a message, so
  * both projections always carry it — and the agent's `answer`, plus where that
  * answer's delivery stands. `successor_id` names the later turn a `merged` or
- * `superseded` record was folded into, `null` on every other outcome. The fields
- * after `updated_at` are ADMIN ONLY — the same door serves a caller-scoped
- * projection that withholds them — so they are optional here and absence means
- * "not published to this reader".
+ * `superseded` record was folded into, `null` on every other outcome. The delivery
+ * bookkeeping fields (`channel`, `our_identity`, `provider_message_id`, `callback_url`,
+ * `error`, `outbound_message_ids`, `attempts`) are ADMIN ONLY — the same door serves a
+ * caller-scoped projection that withholds them, read here as `null`.
  */
-export const conversationMessage = z.object({
-  message_id: z.string(),
-  route_name: z.string(),
-  door: conversationDoor,
-  thread_id: z.string(),
-  client_address: z.string(),
-  caller_principal: z.string().nullable(),
-  inbound_text: z.string(),
-  // A LOOSE array (`null` = no attachments): the key is always present on the wire,
-  // carrying the array or `null`. The renderer `safeParse`s each item against
-  // `attachmentMediaItem`, so one malformed/hostile attachment is a loud per-item
-  // notice, never a whole-record parse failure that vanishes the transcript.
-  inbound_attachments: z.array(z.unknown()).nullable(),
-  answer_status: conversationAnswerStatus.nullable(),
-  answer: z.string().nullable(),
-  successor_id: z.string().nullable(),
-  origin: conversationRecordOrigin,
-  delivery_status: conversationDeliveryStatus,
-  created_at: z.number(),
-  updated_at: z.number(),
-  channel: z.string().nullable().optional(),
-  our_identity: z.string().nullable().optional(),
-  provider_message_id: z.string().nullable().optional(),
-  callback_url: z.string().nullable().optional(),
-  error: z.string().nullable().optional(),
-  outbound_message_ids: z.array(z.string()).optional(),
-  attempts: z.number().optional(),
-});
+export const conversationMessage = openapi.conversationRecordView;
 export type ConversationMessage = z.infer<typeof conversationMessage>;
 
 /**
@@ -163,15 +106,14 @@ export type ConversationMessage = z.infer<typeof conversationMessage>;
  * first); `desc` is the live-tail order, where page 1 is always the newest page
  * and paging forward walks BACKWARDS through the thread's history.
  */
-export const transcriptOrder = z.enum(['asc', 'desc']);
+export const transcriptOrder = openapi.transcriptEnvelope.shape.order;
 export type TranscriptOrder = z.infer<typeof transcriptOrder>;
 
-/** A transcript page, echoing the order it was read in. */
-export const conversationTranscriptPage = z.object({
-  items: z.array(conversationMessage),
-  ...pageWindow,
-  order: transcriptOrder,
-});
+/**
+ * A transcript page, echoing the order it was read in; `person_id` names the person a
+ * person thread aggregates (`null` for a route-keyed thread).
+ */
+export const conversationTranscriptPage = openapi.transcriptEnvelope;
 export type ConversationTranscriptPage = z.infer<typeof conversationTranscriptPage>;
 
 /**
@@ -181,10 +123,7 @@ export type ConversationTranscriptPage = z.infer<typeof conversationTranscriptPa
  * projection. `truncated` says the match set outran the door's scan cap — surfaced
  * loudly, never a silent cut.
  */
-export const conversationMessageSearchPage = z.object({
-  items: z.array(conversationMessage),
-  ...pageWindow,
-});
+export const conversationMessageSearchPage = openapi.messageSearchEnvelope;
 export type ConversationMessageSearchPage = z.infer<typeof conversationMessageSearchPage>;
 
 /**
@@ -192,47 +131,29 @@ export type ConversationMessageSearchPage = z.infer<typeof conversationMessageSe
  * own; `manual` holds the flow back so a human answers. `source` says whether the
  * setting is the thread's own (`thread`) or inherited from its route (`route`).
  */
-export const conversationThreadMode = z.enum(['agent', 'manual']);
+export const conversationThreadMode = openapi.threadModeView.shape.mode;
 export type ConversationThreadMode = z.infer<typeof conversationThreadMode>;
 
-export const conversationThreadModeState = z.object({
-  mode: conversationThreadMode,
-  source: z.enum(['thread', 'route']),
-});
+export const conversationThreadModeState = openapi.threadModeView;
 export type ConversationThreadModeState = z.infer<typeof conversationThreadModeState>;
 
 /** The receipt a thread-message write returns: the stored id and its thread. */
-export const conversationThreadMessageSent = z.object({
-  message_id: z.string(),
-  thread_id: z.string(),
-});
+export const conversationThreadMessageSent = openapi.threadMessageAck;
 export type ConversationThreadMessageSent = z.infer<typeof conversationThreadMessageSent>;
 
 /** Every stored per-target config (`GET /api/conversation-configs`). */
-export const conversationConfigs = z.object({
-  items: z.array(targetConversationConfig),
-  total: z.number(),
-});
+export const conversationConfigs = openapi.conversationConfigListEnvelope;
 export type ConversationConfigs = z.infer<typeof conversationConfigs>;
 
 /**
  * The upsert reply: whether THIS call created the config (vs. replaced an existing
  * one), its key, and the stored row.
  */
-export const conversationConfigWritten = z.object({
-  created: z.boolean(),
-  target_kind: conversationTargetKind,
-  target_name: z.string(),
-  config: targetConversationConfig,
-});
+export const conversationConfigWritten = openapi.conversationConfigSetResult;
 export type ConversationConfigWritten = z.infer<typeof conversationConfigWritten>;
 
 /** The config-delete reply: `removed` is always `true` on success (an unknown key is a 404). */
-export const conversationConfigDeleted = z.object({
-  removed: z.boolean(),
-  target_kind: conversationTargetKind,
-  target_name: z.string(),
-});
+export const conversationConfigDeleted = openapi.conversationConfigDeleteResult;
 export type ConversationConfigDeleted = z.infer<typeof conversationConfigDeleted>;
 
 /**
@@ -240,12 +161,9 @@ export type ConversationConfigDeleted = z.infer<typeof conversationConfigDeleted
  * every answer record whose delivery ended `failed`, across every route and caller.
  * The records are the ADMIN projection (delivery bookkeeping and `error` included),
  * so the row shape is {@link conversationMessage} exactly. It is NOT a paged window —
- * the door returns `{items, total}` and nothing more.
+ * the door returns `{items, total, unreadable}` and nothing more.
  */
-export const conversationFailedMessages = z.object({
-  items: z.array(conversationMessage),
-  total: z.number(),
-});
+export const conversationFailedMessages = openapi.failedConversationsEnvelope;
 export type ConversationFailedMessages = z.infer<typeof conversationFailedMessages>;
 
 /**
@@ -254,11 +172,7 @@ export type ConversationFailedMessages = z.infer<typeof conversationFailedMessag
  * run already cleared them, when they had aged out under retention, or when the id
  * was never stored (forgetting is absolute, never a 404 on a valid id).
  */
-export const conversationThreadDeleted = z.object({
-  removed: z.number(),
-  route_name: z.string(),
-  thread_id: z.string(),
-});
+export const conversationThreadDeleted = openapi.threadDeleteResult;
 export type ConversationThreadDeleted = z.infer<typeof conversationThreadDeleted>;
 
 /**
@@ -267,9 +181,5 @@ export type ConversationThreadDeleted = z.infer<typeof conversationThreadDeleted
  * says whether THIS call removed the person row (`false` on a retry or an
  * already-gone person — never a 404).
  */
-export const conversationPersonDeleted = z.object({
-  person_id: z.string(),
-  removed: z.number(),
-  erased: z.boolean(),
-});
+export const conversationPersonDeleted = openapi.personDeleteResult;
 export type ConversationPersonDeleted = z.infer<typeof conversationPersonDeleted>;

package/src/schemas/extensions.ts

@@ -1,10 +1,14 @@
 /** Extension element/combo and per-tool extension response schemas. */
 import { z } from 'zod';
 
-export const extension = z.object({ name: z.string(), kind: z.string() });
-export const extensions = z.array(extension);
+import * as openapi from '../generated/openapi-schemas';
+
+export const extension = openapi.extensionView;
+export const extensions = openapi.extensionListing;
 export type Extension = z.infer<typeof extension>;
 
+// Hand-written: the spec publishes a config-bearing element as an open object; the client
+// reads its `{ name, config }` form.
 /**
  * One element of an extension combo: a bare extension NAME, or a
  * `{ name, config }` mapping binding author config (e.g. an `output_schema` JSON
@@ -27,8 +31,7 @@ export type PresetExtensionElement = z.infer<typeof presetExtensionElement>;
  * config), never a single flattened one. `available` is the same flat catalog
  * `GET /api/extensions` returns. A drift throws `ApiSchemaError`.
  */
-export const toolExtensions = z.object({
+export const toolExtensions = openapi.toolExtensionsView.extend({
   combos: z.array(z.array(presetExtensionElement)),
-  available: extensions,
 });
 export type ToolExtensions = z.infer<typeof toolExtensions>;