@tai42/api-client 20.0.0 → 22.0.0

package/src/schemas/presets.ts

@@ -1,9 +1,13 @@
 /** Preset record, version and validation response schemas. */
 import { z } from 'zod';
 
+import * as openapi from '../generated/openapi-schemas';
 import { presetExtensionElement } from './extensions';
 import { presetBody } from './served';
 
+// The extension combos and the version body are hand-typed: the spec publishes a
+// config-bearing element and a version body as open objects.
+
 /** A list of extension COMBOS — each combo an ordered list of elements. */
 export const presetExtensions = z.array(z.array(presetExtensionElement));
 
@@ -17,32 +21,13 @@ export const presetExtensions = z.array(z.array(presetExtensionElement));
  * (`GET /api/tool-meta`), never on the record. A drift throws `ApiSchemaError`;
  * nothing is coerced.
  */
-export const presetRecord = z.object({
-  name: z.string(),
-  base_tool: z.string(),
-  description: z.string(),
-  active_version: z.number(),
-  extensions: presetExtensions,
-  output_schema: z.record(z.string(), z.unknown()).nullable(),
-  input_schema: z.record(z.string(), z.unknown()).nullable(),
-  conflicted: z.boolean(),
-  // The human-readable cause a row is quarantined (its name collided with a
-  // foreign tool at boot), or `null` when the row is not conflicted. Rendered
-  // verbatim; nothing is coerced.
-  conflicted_reason: z.string().nullable(),
-  // Sorted preset-name cross-references: `uses` names the presets this one
-  // composes as tools; `used_by` names the presets that compose this one.
-  uses: z.array(z.string()),
-  used_by: z.array(z.string()),
-});
+export const presetRecord = openapi.presetRecordView.extend({ extensions: presetExtensions });
 export type PresetRecord = z.infer<typeof presetRecord>;
 
 export const presetList = z.array(presetRecord);
 
 /** `GET /api/presets/{name}` — the record plus the active version's baked kwargs. */
-export const presetDetail = presetRecord.extend({
-  fixed_kwargs: z.record(z.string(), z.unknown()),
-});
+export const presetDetail = openapi.presetDetailView.extend({ extensions: presetExtensions });
 export type PresetDetail = z.infer<typeof presetDetail>;
 
 /**
@@ -51,29 +36,19 @@ export type PresetDetail = z.infer<typeof presetDetail>;
  * label list (kind-agnostic) — the only preset tags that remain, distinct from the
  * removed record-level categorization and from the tool_meta overlay.
  */
-export const presetVersion = z.object({
-  version: z.number(),
-  body: presetBody,
-  tags: z.array(z.string()),
-  created_at: z.string(),
-  is_current: z.boolean(),
-});
+export const presetVersion = openapi.documentVersion.extend({ body: presetBody });
 export type PresetVersion = z.infer<typeof presetVersion>;
 
 export const presetVersionList = z.array(presetVersion);
 
 /** `POST /api/presets/{name}/rollback` — the re-pointed active version. */
-export const presetRollback = z.object({ name: z.string(), active_version: z.number() });
+export const presetRollback = openapi.presetRollbackResult;
 
 /** `DELETE /api/presets/{name}` — the removed preset. */
-export const presetDeleted = z.object({ name: z.string(), deleted: z.literal(true) });
+export const presetDeleted = openapi.presetDeleteResult;
 
 /** `POST /api/presets/{name}/rename` — the re-keyed record identity. */
-export const presetRenamed = z.object({
-  name: z.string(),
-  renamed_from: z.string(),
-  active_version: z.number(),
-});
+export const presetRenamed = openapi.presetRenameResult;
 export type PresetRenamed = z.infer<typeof presetRenamed>;
 
 /**
@@ -82,10 +57,7 @@ export type PresetRenamed = z.infer<typeof presetRenamed>;
  * empty list is the clean case; a non-empty list means a rename is blocked until
  * those presets are updated. A drift throws `ApiSchemaError`.
  */
-export const presetReferees = z.object({
-  name: z.string(),
-  referees: z.array(z.string()),
-});
+export const presetReferees = openapi.presetRefereesResult;
 export type PresetReferees = z.infer<typeof presetReferees>;
 
 /**
@@ -94,10 +66,7 @@ export type PresetReferees = z.infer<typeof presetReferees>;
  * 200), so `error` carries the server's verbatim message. A drift throws
  * `ApiSchemaError`.
  */
-export const presetValidation = z.object({
-  valid: z.boolean(),
-  error: z.string().nullable(),
-});
+export const presetValidation = openapi.presetValidateVerdict;
 export type PresetValidation = z.infer<typeof presetValidation>;
 
 /**
@@ -106,9 +75,5 @@ export type PresetValidation = z.infer<typeof presetValidation>;
  * response echoes the identity plus the new tag list. A drift throws
  * `ApiSchemaError`.
  */
-export const presetVersionTags = z.object({
-  name: z.string(),
-  version: z.number(),
-  tags: z.array(z.string()),
-});
+export const presetVersionTags = openapi.presetVersionTagsResult;
 export type PresetVersionTags = z.infer<typeof presetVersionTags>;

package/src/schemas/principals.ts

@@ -1,41 +1,34 @@
 /** Principal (identity) reference, row, listing and delete-result schemas. */
-import { z } from 'zod';
+import type { z } from 'zod';
+
+import * as openapi from '../generated/openapi-schemas';
 
 /**
  * A compact reference to a principal — the owner of a key, or the human behind a
  * session — carried inline on payloads that name one.
  */
-export const principalRef = z.object({
-  user_id: z.string(),
-  kind: z.enum(['human', 'service']),
-  display_name: z.string(),
-});
+export const principalRef = openapi.principalRef;
 export type PrincipalRef = z.infer<typeof principalRef>;
 
 /**
- * A principal row (`/api/auth/principals`). `kind` is `human` (logs in
- * interactively) or `service` (holds keys only, never logs in). `created_by` is
- * the principal that created this one, or `null` for the owner the setup door
- * mints. `disabled` turns off every credential the principal owns. `created_at`
- * is an ISO-8601 instant.
+ * A principal's kind: `human` (logs in interactively) or `service` (holds keys only,
+ * never logs in).
+ */
+export const principalKind = openapi.principal.shape.kind;
+export type PrincipalKind = z.infer<typeof principalKind>;
+
+/**
+ * A principal row (`/api/auth/principals`). `created_by` is the principal that created
+ * this one, or `null` for the owner the setup door mints. `disabled` turns off every
+ * credential the principal owns. `created_at` is an ISO-8601 instant.
  */
-export const principal = z.object({
-  user_id: z.string(),
-  kind: z.enum(['human', 'service']),
-  display_name: z.string(),
-  created_by: z.string().nullable(),
-  disabled: z.boolean(),
-  created_at: z.string(),
-});
+export const principal = openapi.principal;
 export type Principal = z.infer<typeof principal>;
 
 /** The principals listing (`GET /api/auth/principals`). */
-export const principalList = z.array(principal);
+export const principalList = openapi.principalListing;
 export type PrincipalList = z.infer<typeof principalList>;
 
 /** The delete result (`DELETE /api/auth/principals/{user_id}`). */
-export const principalDeleted = z.object({
-  user_id: z.string(),
-  deleted: z.boolean(),
-});
+export const principalDeleted = openapi.principalDeleted;
 export type PrincipalDeleted = z.infer<typeof principalDeleted>;

package/src/schemas/profiles.ts

@@ -1,6 +1,7 @@
 /** Settings-profile record, version, diff and apply response schemas. */
-import { z } from 'zod';
+import type { z } from 'zod';
 
+import * as openapi from '../generated/openapi-schemas';
 import { fleetReportFanout } from './fleet';
 
 // The admin-only `/api/config/profiles/*` surface. Secrets ride the wire in the
@@ -13,40 +14,30 @@ import { fleetReportFanout } from './fleet';
  * (No `last_modified`: the list carries identity, not history — version metadata
  * is the `/versions` surface — so the list renders no last-modified column.)
  */
-export const settingsProfileSummary = z.object({
-  name: z.string(),
-  description: z.string(),
-});
+export const settingsProfileSummary = openapi.profileSummary;
 export type SettingsProfileSummary = z.infer<typeof settingsProfileSummary>;
-export const settingsProfileList = z.array(settingsProfileSummary);
+export const settingsProfileList = openapi.profileListResponse;
 
 /**
  * `GET /api/config/profiles/{name}` and each version body — the stored profile
  * document (action=secret). `env` carries REAL values; `secret_keys` is the
  * per-profile secret-marks band folded into the secret-mask union for masking.
  */
-export const settingsProfileBody = z.object({
-  description: z.string(),
-  env: z.record(z.string(), z.string()),
-  secret_keys: z.array(z.string()),
-});
+export const settingsProfileBody = openapi.settingsProfileBody;
 export type SettingsProfileBody = z.infer<typeof settingsProfileBody>;
 
 /** `PUT /api/config/profiles/{name}` — a minimal save ack; `version` is the new store version. */
-export const settingsProfileSaved = z.object({
-  ok: z.literal(true),
-  version: z.number().optional(),
-});
+export const settingsProfileSaved = openapi.profileWriteResult;
 export type SettingsProfileSaved = z.infer<typeof settingsProfileSaved>;
 
 /** `DELETE /api/config/profiles/{name}` — a minimal removal ack. */
-export const settingsProfileDeleted = z.object({ ok: z.literal(true) });
+export const settingsProfileDeleted = openapi.okResult;
 
-/** `POST /api/config/profiles/{name}/rollback` — the restore ack; `version` is the resulting active version. */
-export const settingsProfileRollback = z.object({
-  ok: z.literal(true),
-  version: z.number(),
-});
+/**
+ * `POST /api/config/profiles/{name}/rollback` — the restore ack; `version` is the resulting
+ * active version.
+ */
+export const settingsProfileRollback = openapi.profileWriteResult;
 export type SettingsProfileRollback = z.infer<typeof settingsProfileRollback>;
 
 /**
@@ -55,13 +46,7 @@ export type SettingsProfileRollback = z.infer<typeof settingsProfileRollback>;
  * JsonDiff); `recycle_keys`/`refused_keys` are the diff's recycle-class and
  * boundary-refused key names, called out in the UI before apply.
  */
-export const settingsProfileDiff = z.object({
-  added: z.array(z.string()),
-  removed: z.array(z.string()),
-  changed: z.array(z.object({ key: z.string(), old: z.string(), new: z.string() })),
-  recycle_keys: z.array(z.string()),
-  refused_keys: z.array(z.string()),
-});
+export const settingsProfileDiff = openapi.profileDiff;
 export type SettingsProfileDiff = z.infer<typeof settingsProfileDiff>;
 
 /**
@@ -73,24 +58,16 @@ export type SettingsProfileDiff = z.infer<typeof settingsProfileDiff>;
  * the `self-deferred` status literal when the diff has serve-affecting recycle keys;
  * `fresh` is the per-kind list of NEW ready lives observed since the pre-apply snapshot
  * (each `{name, kind, generation}`), evidence of fresh capacity and never claimed as any
- * target's successor; `refused` is `[]` on success by construction (populated
- * `{key, reason}` only on a refusal), the populated refusal surfaces being the diff
- * preview and the refusal error report. `fanout` is the mode-wrapped fleet broadcast,
- * parsed EXPLICITLY so a failed propagation reaches the shared fleet-report handler. A
- * drift throws `ApiSchemaError`.
+ * target's successor; `refused` is `[]` on success by construction (the refused key
+ * names only on a refusal), the populated refusal surfaces being the diff preview and
+ * the refusal error report; `recycle_stopped` names the target a stopped recycle roll
+ * halted at, or is `null` when the roll ran to its end; `awaiting_respawn` names the
+ * workers (name + keys) still awaiting a respawn after the apply (empty when the roll
+ * converged). `fanout` is the mode-wrapped fleet broadcast, parsed EXPLICITLY so a failed
+ * propagation reaches the shared fleet-report handler. A drift throws `ApiSchemaError`.
  */
-export const profileApplyResponse = z.object({
-  hot: z.array(z.string()),
-  recycle: z.array(
-    z.object({
-      name: z.string(),
-      kind: z.string(),
-      status: z.string(),
-      generation_before: z.number(),
-    }),
-  ),
-  fresh: z.array(z.object({ name: z.string(), kind: z.string(), generation: z.number() })),
-  refused: z.array(z.object({ key: z.string(), reason: z.string() })),
+// The fan-out is hand-typed: the spec publishes it as one object with optional fields.
+export const profileApplyResponse = openapi.profileApplyResponse.extend({
   fanout: fleetReportFanout,
 });
 export type ProfileApplyResponse = z.infer<typeof profileApplyResponse>;
@@ -100,21 +77,14 @@ export type ProfileApplyResponse = z.infer<typeof profileApplyResponse>;
  * no bodies), the generic versioned-store row minus `body`. `is_current` flags the
  * active pointer.
  */
-export const settingsProfileVersionMeta = z.object({
-  version: z.number(),
-  tags: z.array(z.string()),
-  created_at: z.string(),
-  is_current: z.boolean(),
-});
+export const settingsProfileVersionMeta = openapi.profileVersionSummary;
 export type SettingsProfileVersionMeta = z.infer<typeof settingsProfileVersionMeta>;
-export const settingsProfileVersionList = z.array(settingsProfileVersionMeta);
+export const settingsProfileVersionList = openapi.profileVersionListResponse;
 
 /**
  * `GET /api/config/profiles/{name}/versions/{version}` — one immutable version WITH
  * its `body` (action=secret; body rendered masked per the secret-mask union). The generic
  * versioned-store row shape.
  */
-export const settingsProfileVersion = settingsProfileVersionMeta.extend({
-  body: settingsProfileBody,
-});
+export const settingsProfileVersion = openapi.profileVersionView;
 export type SettingsProfileVersion = z.infer<typeof settingsProfileVersion>;

package/src/schemas/roles.ts

@@ -1,34 +1,32 @@
 /** Role grant, version and audit response schemas. */
 import { z } from 'zod';
 
+import * as openapi from '../generated/openapi-schemas';
 import { roleBody } from './served';
 import { jsonValue } from './shared';
 
 /** A role's per-tag ACCESS LEVEL: `none` (no access), `read`, or `write`. */
-export const grantLevel = z.enum(['none', 'read', 'write']);
+export const grantLevel = roleBody.shape.grants.valueType;
 export type GrantLevel = z.infer<typeof grantLevel>;
 
 /** A role's editable grant map: feature-group TAG name → the role's access level. */
-export const roleGrants = z.record(z.string(), grantLevel);
+export const roleGrants = roleBody.shape.grants;
 export type RoleGrants = z.infer<typeof roleGrants>;
 
-export const roleList = z.array(roleBody);
+export const roleList = openapi.roleDefinitionList;
 
 /** `DELETE /api/auth/roles/{name}` — the deleted role's name. */
-export const roleDeleted = z.object({ name: z.string(), deleted: z.boolean() });
+export const roleDeleted = openapi.roleDeleted;
+
+// The version and audit bodies are hand-typed: the spec publishes a version body as an open
+// object.
 
 /**
  * One immutable role-version row (`GET /api/auth/roles/{name}/versions` →
  * `versions`). `body` is the role body at that version; `is_current` flags the
  * active pointer. Mirrors the generic versioned-store row shape.
  */
-export const roleVersion = z.object({
-  version: z.number(),
-  body: roleBody,
-  tags: z.array(z.string()),
-  created_at: z.string(),
-  is_current: z.boolean(),
-});
+export const roleVersion = openapi.documentVersion.extend({ body: roleBody });
 export type RoleVersion = z.infer<typeof roleVersion>;
 
 /**
@@ -36,22 +34,18 @@ export type RoleVersion = z.infer<typeof roleVersion>;
  * `audit`). Its `body` carries the mutation kind, the actor, and the before/after
  * role bodies (both `null` for a create's `before` / a delete's `after`).
  */
-export const roleAuditEvent = z.object({
-  version: z.number(),
+export const roleAuditEvent = openapi.documentVersion.extend({
   body: z.object({
     action: z.string(),
     actor: z.string().nullable(),
     before: jsonValue.nullable(),
     after: jsonValue.nullable(),
   }),
-  tags: z.array(z.string()),
-  created_at: z.string(),
-  is_current: z.boolean(),
 });
 export type RoleAuditEvent = z.infer<typeof roleAuditEvent>;
 
 /** `GET /api/auth/roles/{name}/versions` — the append-only history + audit trail. */
-export const roleVersions = z.object({
+export const roleVersions = openapi.roleVersionsView.extend({
   versions: z.array(roleVersion),
   audit: z.array(roleAuditEvent),
 });

package/src/schemas/schedules.ts

@@ -1,23 +1,12 @@
 /** Schedule listing and server-clock response schemas. */
 import { z } from 'zod';
 
+import * as openapi from '../generated/openapi-schemas';
 import { jsonValue } from './shared';
 
-// The skeleton returns opaque backend-tool results; the table reads a few known
-// fields and passes the rest through untouched.
-
-export const scheduleItem = z
-  .object({
-    name: z.string(),
-    enabled: z.boolean().optional(),
-    schedule: jsonValue.optional(),
-    target: jsonValue.optional(),
-    args: z.array(jsonValue).optional(),
-    kwargs: z.record(z.string(), jsonValue).optional(),
-  })
-  .loose();
-export const scheduleList = z.array(scheduleItem);
-export type ScheduleItem = z.infer<typeof scheduleItem>;
+// The listing is the generated `ScheduleListRow` array the server publishes (name, tool,
+// typed cadence, enabled, next run, an optional backend error — never tool arguments).
+export const scheduleList = openapi.scheduleListResponse;
 
 export const serverDateTime = z
   .object({

package/src/schemas/served.ts

@@ -22,6 +22,10 @@ export const presetBody = generated.presetBody;
 export type PresetBody = z.input<typeof presetBody>;
 export const conversationRoute = generated.conversationRoute;
 export type ConversationRoute = z.infer<typeof conversationRoute>;
+export const apiConversationRouteCreate = generated.apiConversationRouteCreate;
+export type ApiConversationRouteCreate = z.input<typeof apiConversationRouteCreate>;
+export const channelConversationRouteCreate = generated.channelConversationRouteCreate;
+export type ChannelConversationRouteCreate = z.input<typeof channelConversationRouteCreate>;
 export const conversationRouteCreate = generated.conversationRouteCreate;
 export type ConversationRouteCreate = z.input<typeof conversationRouteCreate>;
 export const targetConversationConfig = generated.targetConversationConfig;
@@ -44,7 +48,36 @@ export const templateReconcile = generated.stateTemplateReconcile;
 export type TemplateReconcile = z.infer<typeof templateReconcile>;
 export const templateDeclarations = generated.stateTemplateDeclarations;
 export type TemplateDeclarations = z.infer<typeof templateDeclarations>;
+export const stateTemplateParameter = generated.stateTemplateParameter;
+export type StateTemplateParameter = z.infer<typeof stateTemplateParameter>;
+export const stateRegimeRule = generated.stateRegimeRule;
+export type StateRegimeRule = z.infer<typeof stateRegimeRule>;
+export const stateTemplateTrace = generated.stateTemplateTrace;
+export type StateTemplateTrace = z.infer<typeof stateTemplateTrace>;
 export const policyBody = generated.accessPolicy;
 export type PolicyBody = z.infer<typeof policyBody>;
 export const roleBody = generated.roleDefinition;
 export type RoleBody = z.infer<typeof roleBody>;
+export const settingsProfileName = generated.settingsProfileName;
+export type SettingsProfileName = z.infer<typeof settingsProfileName>;
+export const previousProfileName = generated.previousProfileName;
+export type PreviousProfileName = z.infer<typeof previousProfileName>;
+export const scheduleCreate = generated.scheduleCreate;
+export type ScheduleCreate = z.input<typeof scheduleCreate>;
+export const scheduleListRow = generated.scheduleListRow;
+export type ScheduleListRow = z.infer<typeof scheduleListRow>;
+export const scheduleRecord = generated.scheduleRecord;
+export type ScheduleRecord = z.infer<typeof scheduleRecord>;
+
+/**
+ * The platform constants the contract serves, read instead of re-spelled: the reserved
+ * person subject kind (`PERSON_KIND`), the same-origin served-media route prefix
+ * (`MEDIA_ROUTE_PREFIX`) and the stored-media id grammar (`MEDIA_ID_PATTERN`, a regular
+ * expression matched against a whole id).
+ */
+export const servedConstants = generated.servedConstants;
+export type ServedConstants = typeof servedConstants;
+/** The conformance vectors of the platform rules a browser mirrors. */
+export const servedVectors = generated.servedVectors;
+/** Each served document as JSON Schema, with the `$defs` it references. */
+export const servedDocumentsJson = generated.servedDocumentsJson;

package/src/schemas/settings-schema.ts

@@ -1,32 +1,27 @@
 /** Declarative settings-form schema response. */
 import { z } from 'zod';
 
+import * as openapi from '../generated/openapi-schemas';
 import { jsonValue } from './shared';
 
 // The settings form is auto-rendered from a declarative group/field description
-// the skeleton emits from its typed settings models.
+// the skeleton emits from its typed settings models. Each field is hand-typed: the spec
+// publishes a field as an open object.
 
-export const settingsSchema = z.object({
-  groups: z.array(
-    z.object({
-      name: z.string(),
-      module: z.string(),
-      qualname: z.string(),
-      fields: z.array(
-        z.object({
-          name: z.string(),
-          env_var: z.string(),
-          type: z.string(),
-          default: jsonValue.nullable(),
-          required: z.boolean(),
-          secret: z.boolean(),
-          description: z.string().nullable(),
-          nested_group: z.string().nullable(),
-          default_namespace_var: z.string().nullable(),
-          value: jsonValue.nullable(),
-        }),
-      ),
-    }),
-  ),
+const settingsField = z.object({
+  name: z.string(),
+  env_var: z.string(),
+  type: z.string(),
+  default: jsonValue.nullable(),
+  required: z.boolean(),
+  secret: z.boolean(),
+  description: z.string().nullable(),
+  nested_group: z.string().nullable(),
+  default_namespace_var: z.string().nullable(),
+  value: jsonValue.nullable(),
+});
+
+export const settingsSchema = openapi.settingsSchemaView.extend({
+  groups: z.array(openapi.settingsGroupView.extend({ fields: z.array(settingsField) })),
 });
 export type SettingsSchema = z.infer<typeof settingsSchema>;

package/src/schemas/setup.ts

@@ -1,5 +1,7 @@
 /** Setup-door (`POST /api/setup`) request-body and result schemas. */
-import { z } from 'zod';
+import type { z } from 'zod';
+
+import * as openapi from '../generated/openapi-schemas';
 
 /**
  * The result of a successful `POST /api/setup`, returned exactly ONCE. `api_key`
@@ -8,15 +10,7 @@ import { z } from 'zod';
  * `invite_token` and `login_path` are set only when the attachment was an invite
  * the operator completes later.
  */
-export const setupResult = z.object({
-  owner_user_id: z.string(),
-  key_user_id: z.string(),
-  api_key: z.string().min(1),
-  key_fingerprint: z.string(),
-  login_attached: z.boolean(),
-  invite_token: z.string().nullable().optional(),
-  login_path: z.string().nullable().optional(),
-});
+export const setupResult = openapi.setupResult;
 export type SetupResult = z.infer<typeof setupResult>;
 
 /**