@tai42/api-client 20.0.0 → 21.0.0

package/src/schemas/states.ts

@@ -1,28 +1,20 @@
 /** State declaration, record, template and consumer response schemas. */
 import { z } from 'zod';
 
-import { conversationTargetKind } from './conversations';
+import * as openapi from '../generated/openapi-schemas';
+import * as served from '../generated/served-schemas';
 import { stateDeclaration, stateTemplateDocument } from './served';
 
-// The hand-written state response DTOs — list rows and detail (built on the generated
-// `stateDeclaration`), attachments, per-subject records and subjects, stats and consumers.
-// The served DOCUMENT schemas (`stateDeclaration`/`stateTemplateDocument` and the template
-// sub-shapes) are generated from the contract bundle and re-exported at the top of this
-// file. The composed `effective_schema` and write `regimes` stay permissive JSON records
-// (the auto-form and JsonTree interpret them at runtime) and are server-computed, so they
-// are modelled optional and a response that omits them still parses.
+// The state response schemas — list rows and detail, attachments, per-subject records and
+// subjects, stats and consumers. The served DOCUMENT schemas (`stateDeclaration`/
+// `stateTemplateDocument` and the template sub-shapes) are re-exported from `./served`.
 
 /** One addressed subject: the conversation-target scope plus the (kind, key) within it. */
-export const stateSubject = z.object({
-  target_kind: conversationTargetKind,
-  target_name: z.string(),
-  kind: z.string(),
-  key: z.string(),
-});
+export const stateSubject = openapi.stateSubject;
 export type StateSubject = z.infer<typeof stateSubject>;
 
-/** One absolute write-regime rule composed over the attachments: `{path, regime}`, permissive. */
-export const stateRegime = z.record(z.string(), z.unknown());
+/** One absolute write-regime rule composed over the attachments: `{path, regime}`. */
+export const stateRegime = served.stateRegimeRule;
 
 /**
  * One row of `GET /api/states` — a served declaration (`list_states` dumps every
@@ -30,40 +22,44 @@ export const stateRegime = z.record(z.string(), z.unknown());
  * `null`). The list carries no record count; the `Records` column reads
  * `getStateStats` lazily per row.
  */
-export const stateListItem = stateDeclaration.extend({
-  updated_at: z.string().nullable().default(null),
-});
+export const stateListItem = stateDeclaration;
 export type StateListItem = z.infer<typeof stateListItem>;
-export const stateList = z.array(stateListItem);
+export const stateList = openapi.stateDeclarationList;
+
+/**
+ * One save held by a failed pending save: `save_id` names it, `held_by` the failed save holding it
+ * (equal to `save_id` for the failed save itself), `subjects` the subjects it writes. A scan or
+ * a re-declare that read past it names it in its `held` list.
+ */
+export const heldPendingSave = openapi.heldPendingSave;
+export type HeldPendingSave = z.infer<typeof heldPendingSave>;
 
 /** One template attachment on a state: where the fragment lands + its param/declaration values. */
-export const stateAttachment = z.object({
-  template: z.string(),
-  path: z.array(z.string()),
-  parameters: z.record(z.string(), z.unknown()).default({}),
-  declarations: z.record(z.string(), z.unknown()).default({}),
-});
+export const stateAttachment = openapi.stateAttachmentView;
 export type StateAttachment = z.infer<typeof stateAttachment>;
-export const stateAttachmentList = z.array(stateAttachment);
+export const stateAttachmentList = openapi.stateAttachmentList;
 
 /** `GET /api/states/{name}` — the declaration (with effective schema + regimes) plus attachments. */
-export const stateDetail = stateDeclaration.extend({
-  attachments: z.array(stateAttachment).default([]),
-});
+// Built on the declaration document: the spec publishes the served view's `schema` and
+// `regimes` as open objects, the document types them.
+export const stateDetail = stateDeclaration.extend({ attachments: z.array(stateAttachment) });
 export type StateDetail = z.infer<typeof stateDetail>;
 
+/**
+ * `PUT /api/states/{name}` — a create or re-declare's answer: the stored declaration's fields
+ * plus `held`, the held pending saves an accepted re-declare names (absent when none). The
+ * answer carries no attachments; a caller that needs them reads `getState`.
+ */
+export const stateDeclarationSaved = openapi.stateDeclarationPutResponse;
+export type StateDeclarationSaved = z.infer<typeof stateDeclarationSaved>;
+
 /**
  * `GET /api/states/{name}/stats` — `records` (total documents), `per_field` (the count
  * of records carrying each base-schema property), `per_kind` (records per subject kind)
  * and `consumers` (the count of listable consumers). The Records tab shows `records`;
  * the states list reads it lazily for its Records column.
  */
-export const stateStats = z.object({
-  records: z.number(),
-  per_field: z.record(z.string(), z.number()).default({}),
-  per_kind: z.record(z.string(), z.number()).default({}),
-  consumers: z.number().default(0),
-});
+export const stateStats = openapi.stateStats;
 export type StateStats = z.infer<typeof stateStats>;
 
 /**
@@ -72,31 +68,21 @@ export type StateStats = z.infer<typeof stateStats>;
  * while > 0) and `shipped_default` (a platform-shipped template). Both are server-derived
  * columns; the document fields are verbatim.
  */
+// Built on the template document: the spec publishes a served template's jq programs as open
+// objects, the document types them.
 export const stateTemplateListItem = stateTemplateDocument.extend({
-  attached_to: z.number().default(0),
-  shipped_default: z.boolean().default(false),
+  attached_to: openapi.stateTemplateCatalogEntry.shape.attached_to,
+  shipped_default: openapi.stateTemplateCatalogEntry.shape.shipped_default,
 });
 export type StateTemplateListItem = z.infer<typeof stateTemplateListItem>;
 export const stateTemplateList = z.array(stateTemplateListItem);
 
 /** A read record: the state, its subject, the document + monotonic seq, and any fold. */
-export const stateRecord = z.object({
-  state: z.string(),
-  subject: stateSubject,
-  data: z.record(z.string(), z.unknown()).default({}),
-  seq: z.number(),
-  canonical_subject: stateSubject,
-  folded_from: z.array(stateSubject).default([]),
-});
+export const stateRecord = openapi.stateRecord;
 export type StateRecord = z.infer<typeof stateRecord>;
 
 /** The outcome of an `apply` (a delta batch): whether it applied + the resulting doc. */
-export const applyResult = z.object({
-  applied: z.boolean(),
-  data: z.record(z.string(), z.unknown()).nullable().default(null),
-  seq: z.number().nullable().default(null),
-  skipped: z.array(z.record(z.string(), z.unknown())).default([]),
-});
+export const applyResult = openapi.applyResult;
 export type ApplyResult = z.infer<typeof applyResult>;
 
 /**
@@ -105,11 +91,7 @@ export type ApplyResult = z.infer<typeof applyResult>;
  * on an `update`-purpose name is refused with 422, so the result's purpose is always
  * `input`.
  */
-export const templateJqResult = z.object({
-  name: z.string(),
-  purpose: z.literal('input'),
-  value: z.unknown(),
-});
+export const templateJqResult = openapi.templateJqResult;
 export type TemplateJqResult = z.infer<typeof templateJqResult>;
 
 /**
@@ -117,13 +99,7 @@ export type TemplateJqResult = z.infer<typeof templateJqResult>;
  * batch through the same `apply` chokepoint as a delta, so `applied`/`data`/`seq`/`skipped`
  * carry that outcome.
  */
-export const templateJqApplyResult = z.object({
-  name: z.string(),
-  applied: z.boolean(),
-  data: z.record(z.string(), z.unknown()).nullable().default(null),
-  seq: z.number().nullable().default(null),
-  skipped: z.array(z.record(z.string(), z.unknown())).default([]),
-});
+export const templateJqApplyResult = openapi.templateJqApplyResult;
 export type TemplateJqApplyResult = z.infer<typeof templateJqApplyResult>;
 
 /**
@@ -131,10 +107,7 @@ export type TemplateJqApplyResult = z.infer<typeof templateJqApplyResult>;
  * `updated_at` — epoch seconds (the store's `extract(epoch FROM updated_at)`), served
  * raw (no `mode="json"` dump), and `NOT NULL` on every record, so a plain number.
  */
-export const subjectRow = z.object({
-  subject: stateSubject,
-  updated_at: z.number(),
-});
+export const subjectRow = openapi.stateSubjectEntry;
 export type SubjectRow = z.infer<typeof subjectRow>;
 
 /**
@@ -142,10 +115,7 @@ export type SubjectRow = z.infer<typeof subjectRow>;
  * `kind`): the matched `subjects` plus the `next_cursor` a "Load more" carries back
  * (`null` at the end).
  */
-export const subjectPage = z.object({
-  subjects: z.array(subjectRow),
-  next_cursor: z.string().nullable().default(null),
-});
+export const subjectPage = openapi.stateSubjectsPage;
 export type SubjectPage = z.infer<typeof subjectPage>;
 
 /**
@@ -153,48 +123,23 @@ export type SubjectPage = z.infer<typeof subjectPage>;
  * document contains the filters (a JSONB containment match). Each hit's `subject` opens
  * the record page; `next_cursor` pages the rest.
  */
-export const recordSearchPage = z.object({
-  matches: z.array(subjectRow),
-  next_cursor: z.string().nullable().default(null),
-});
+export const recordSearchPage = openapi.stateSearchPage;
 export type RecordSearchPage = z.infer<typeof recordSearchPage>;
 
 /** A WriteEntry's origin completed by the platform chokepoint (mirrors CompletedOrigin). */
-export const completedOrigin = z.object({
-  consumer: z.string().nullable().default(null),
-  // Opaque consumer-supplied provenance JSON the platform stores as is.
-  meta: z.record(z.string(), z.unknown()).nullable().default(null),
-  run_id: z.string().nullable().default(null),
-  op_id: z.string().nullable().default(null),
-  door: z.string(),
-  actor: z.string().nullable().default(null),
-  turn_id: z.string().nullable().default(null),
-  inbound_id: z.string().nullable().default(null),
-});
+export const completedOrigin = openapi.completedOrigin;
 export type CompletedOrigin = z.infer<typeof completedOrigin>;
 
 /** One row of a subject's audit trail (mirrors WriteEntry). `paths` are absolute. */
-export const writeEntry = z.object({
-  seq: z.number(),
-  at: z.string(),
-  origin: completedOrigin,
-  paths: z.array(z.array(z.union([z.string(), z.number()]))).default([]),
-});
+export const writeEntry = openapi.writeEntry;
 export type WriteEntry = z.infer<typeof writeEntry>;
 
 /** `GET /api/states/{name}/records/.../writes` — a keyset page of the audit trail. */
-export const writesPage = z.object({
-  items: z.array(writeEntry),
-  next_cursor: z.string().nullable().default(null),
-});
+export const writesPage = openapi.writesPage;
 export type WritesPage = z.infer<typeof writesPage>;
 
 /** Where the Studio opens a consumer (mirrors ConsumerLink): a token+search OR plugin path. */
-export const consumerLink = z.object({
-  token: z.string().nullable().default(null),
-  plugin_path: z.string().nullable().default(null),
-  search: z.record(z.string(), z.unknown()).nullable().default(null),
-});
+export const consumerLink = openapi.consumerLink;
 export type ConsumerLink = z.infer<typeof consumerLink>;
 
 /**
@@ -203,71 +148,75 @@ export type ConsumerLink = z.infer<typeof consumerLink>;
  * family that cannot be listed on this deployment (e.g. no scheduling backend), surfaced
  * as a muted line — never swallowed.
  */
-export const consumerRow = z.object({
-  kind: z.string(),
-  name: z.string().nullable().default(null),
-  detail: z.string().nullable().default(null),
-  link: consumerLink.nullable().default(null),
-  unavailable: z.string().nullable().default(null),
-});
+export const consumerRow = openapi.consumerRow;
 export type ConsumerRow = z.infer<typeof consumerRow>;
 
 /** `GET /api/states/{name}/consumers` — the union of every registered lister's rows. */
-export const stateConsumers = z.array(consumerRow);
+export const stateConsumers = openapi.stateConsumerList;
 export type StateConsumers = z.infer<typeof stateConsumers>;
 
 /** `DELETE /api/states/{name}` — the removed state. */
-export const stateDeleted = z.object({ name: z.string(), deleted: z.literal(true) });
+export const stateDeleted = openapi.stateDeleteResult;
 
 /** `PUT /api/states/{name}/attachments/{template}` — the template now attached to the state. */
-export const stateAttached = z.object({
-  attached: z.literal(true),
-  state: z.string(),
-  template: z.string(),
-});
+export const stateAttached = openapi.attachAck;
 export type StateAttached = z.infer<typeof stateAttached>;
 
 /** `PATCH /api/states/{name}/attachments/{template}` — the attachment whose declarations were rewritten. */
-export const stateAttachmentUpdated = z.object({
-  updated: z.literal(true),
-  state: z.string(),
-  template: z.string(),
-});
+export const stateAttachmentUpdated = openapi.attachUpdateAck;
 export type StateAttachmentUpdated = z.infer<typeof stateAttachmentUpdated>;
 
 /** `DELETE /api/states/{name}/attachments/{template}` — the template detached from the state. */
-export const stateDetached = z.object({
-  detached: z.literal(true),
-  state: z.string(),
-  template: z.string(),
-});
+export const stateDetached = openapi.detachAck;
 export type StateDetached = z.infer<typeof stateDetached>;
 
 /**
  * `POST /api/states/{name}/records/.../fold` — the fold report: the `mode`, the
  * `{kind, key}` of the folded `from` and surviving `into` subjects, whether the fold
- * was `already` in place, and how many records were `flattened` into the survivor.
+ * was `already` in place, how many records were `flattened` into the survivor, and
+ * (a `merge` fold only) the survivor's newly-filled `merged_members`.
  */
-export const stateFoldReport = z.object({
-  mode: z.enum(['switch', 'merge']),
-  from: z.object({ kind: z.string(), key: z.string() }),
-  into: z.object({ kind: z.string(), key: z.string() }),
-  already: z.boolean(),
-  flattened: z.number().default(0),
-});
+export const stateFoldReport = openapi.foldReport;
 export type StateFoldReport = z.infer<typeof stateFoldReport>;
 
 /** `DELETE /api/state-templates/{name}` — the removed template document. */
-export const stateTemplateDeleted = z.object({ name: z.string(), deleted: z.literal(true) });
+export const stateTemplateDeleted = openapi.stateDeleteResult;
 
 /** `DELETE /api/states/{name}/records/...` — the erased record marker. */
-export const recordErased = z.object({ erased: z.literal(true) });
+export const recordErased = openapi.eraseAck;
 
 /**
  * `POST /api/state-retention/prune` — the retention sweep's per-state deleted counts
  * (`{}` when nothing expired); the UI sums the values for its total.
  */
-export const stateRetentionPruned = z.object({
-  pruned: z.record(z.string(), z.number()).default({}),
-});
+export const stateRetentionPruned = openapi.pruneResult;
 export type StateRetentionPruned = z.infer<typeof stateRetentionPruned>;
+
+/** A pending save's lifecycle: records waiting, calls queued, a call running, or failed (held). */
+export const pendingSaveStatus = openapi.statePendingSave.shape.status;
+export type PendingSaveStatus = z.infer<typeof pendingSaveStatus>;
+
+/**
+ * One outstanding pending state save (`GET /api/state-pending-saves`): what it writes and calls,
+ * never the record data or call arguments. `failed_phase` says which part failed.
+ */
+export const pendingSave = openapi.statePendingSave;
+export type PendingSave = z.infer<typeof pendingSave>;
+
+/**
+ * A page of pending saves, newest first, with the totals of every `outstanding` and every
+ * `failed` save; `next_cursor` continues the page (`null` at the end).
+ */
+export const pendingSavesPage = openapi.statePendingSavesPage;
+export type PendingSavesPage = z.infer<typeof pendingSavesPage>;
+
+/**
+ * `POST /api/state-pending-saves/{id}/retry` — the save's status after its records phase:
+ * `applied` (it landed whole), `pending`/`calls`/`running` (queued again), or `failed` again
+ * with its `last_error`.
+ */
+export const pendingSaveRetried = openapi.statePendingSaveRetried;
+export type PendingSaveRetried = z.infer<typeof pendingSaveRetried>;
+
+/** `DELETE /api/state-pending-saves/{id}` — the discarded save's id. */
+export const pendingSaveDiscarded = openapi.statePendingSaveDiscarded;

package/src/schemas/storage.ts

@@ -1,31 +1,25 @@
 /** Storage-provider info and resource CRUD response schemas. */
-import { z } from 'zod';
+import type { z } from 'zod';
+
+import * as openapi from '../generated/openapi-schemas';
 
 /** `GET /api/storage` — the storage-provider identity, or the absent sentinel
  * (`present: false`, a 200) when no storage-provider plugin is installed. */
-export const storageInfo = z.object({
-  present: z.boolean(),
-  provider: z.string().nullable(),
-  module: z.string().nullable(),
-});
+export const storageInfo = openapi.storageInfo;
 export type StorageInfo = z.infer<typeof storageInfo>;
 
 /** `GET /api/storage/resources` — the full sorted resource-id list. */
-export const storageResourceList = z.object({ resources: z.array(z.string()) });
+export const storageResourceList = openapi.resourceList;
 
-/** `GET /api/storage/resources/{id}/stat` — an object's inferred content type;
- * `null` when the provider cannot infer one (e.g. an unknown suffix). */
-export const storageResourceStat = z.object({
-  id: z.string(),
-  content_type: z.string().nullable(),
-});
+/** `GET /api/storage/resources/{id}/stat` — an object's inferred content type. */
+export const storageResourceStat = openapi.resourceStat;
 export type StorageResourceStat = z.infer<typeof storageResourceStat>;
 
 /** `POST /api/storage/resources` — the stored object's id. */
-export const storageResourceStored = z.object({ id: z.string(), stored: z.literal(true) });
+export const storageResourceStored = openapi.resourceStored;
 
 /** `DELETE /api/storage/resources/{id}` — the removed object's id. */
-export const storageResourceDeleted = z.object({ id: z.string(), deleted: z.literal(true) });
+export const storageResourceDeleted = openapi.resourceDeleted;
 
 /** `DELETE /api/storage/dirs/{path}` — the removed directory subtree. */
-export const storageDirDeleted = z.object({ dir: z.string(), deleted: z.literal(true) });
+export const storageDirDeleted = openapi.dirDeleted;

package/src/schemas/studio-plugins.ts

@@ -1,21 +1,10 @@
 /** Studio front-end plugin registry response schemas. */
-import { z } from 'zod';
+import type { z } from 'zod';
 
-export const studioPluginManifest = z.object({
-  name: z.string(),
-  version: z.string(),
-  api_version: z.number(),
-  entry: z.string(),
-  integrity: z.record(z.string(), z.string()),
-  contributions: z.object({
-    tool_panels: z.record(z.string(), z.string()).default({}),
-    pages: z.array(z.string()).default([]),
-    settings_tabs: z.array(z.string()).default([]),
-    // Optional with a default so a manifest without the field still parses; the
-    // non-strict object would otherwise SILENTLY STRIP an undeclared field, so a
-    // server that serves `nav_entries` would never reach the UI.
-    nav_entries: z.array(z.string()).default([]),
-  }),
-});
-export const studioPluginRegistry = z.array(studioPluginManifest);
-export type StudioPluginManifest = z.infer<typeof studioPluginManifest>;
+import * as openapi from '../generated/openapi-schemas';
+
+/** One installed plugin's manifest plus `mounts`: its own route items and the absolute
+ *  base each is served under on this deployment (`{item: "/api/<base>"}`). */
+export const studioPluginListingEntry = openapi.studioPluginListingEntry;
+export const studioPluginRegistry = openapi.studioPluginListing;
+export type StudioPluginListingEntry = z.infer<typeof studioPluginListingEntry>;

package/src/schemas/sub-mcp.ts

@@ -1,24 +1,18 @@
 /** Sub-MCP mount registry response schemas. */
-import { z } from 'zod';
+import type { z } from 'zod';
+
+import * as openapi from '../generated/openapi-schemas';
 
 /**
- * One registered sub-MCP mount as it rides the registry list and the projection:
- * the tools it exposes and the transport it serves on. In `GET /api/sub-mcp` the
- * slug is the map key, so the mount value carries no slug; {@link subMcpEntry}
- * extends this with `slug` for the capability projection where mounts are a flat
- * list. `transport` is always present on the wire (the server defaults it to
- * `http`), so it is required — its absence is a drift, not a legal shape.
+ * One registered sub-MCP mount as it rides the registry list: the tools it exposes, the
+ * transport it serves on, the served `mount_url` (the URL the mount is served at and its
+ * route-table key) and the served `access_pattern` (the dynamic route pattern mapping every
+ * sub-path of the mount to that key). In `GET /api/sub-mcp` the slug is the map key, so the
+ * mount value carries no slug.
  */
-export const subMcpMount = z.object({
-  tools: z.array(z.string()),
-  transport: z.string(),
-});
+export const subMcpMount = openapi.subMcpListingEntry;
 export type SubMcpMount = z.infer<typeof subMcpMount>;
 
-export const subMcpList = z.record(z.string(), subMcpMount);
-export const subMcpCreated = z.object({
-  slug: z.string(),
-  tools: z.array(z.string()),
-  transport: z.string(),
-});
-export const subMcpRemoved = z.object({ slug: z.string(), removed: z.literal(true) });
+export const subMcpList = openapi.subMcpMapListing;
+export const subMcpCreated = openapi.subMcpRegistrationResult;
+export const subMcpRemoved = openapi.subMcpRemovalResult;

package/src/schemas/system-kinds.ts

@@ -1,6 +1,7 @@
 /** Pluggable-kind status and MCP status/reload response schemas. */
-import { z } from 'zod';
+import type { z } from 'zod';
 
+import * as openapi from '../generated/openapi-schemas';
 import { fleetResult } from './fleet';
 import { reloadConfigResult } from './manifest-mcp';
 
@@ -9,16 +10,10 @@ import { reloadConfigResult } from './manifest-mcp';
 // studio_plugins). `state` is the kind's active/default/off status: `active` = a
 // real plugin serves it, `default` = a built-in fallback serves it, `off` =
 // nothing is registered (a legal state, reported not "fixed"). `plugin` is the
-// provider/module name when known, else null. Plain (non-strict) `z.object` so a
-// server that adds a field to the row still parses.
+// provider/module name when known, else null.
 
-export const kindStatus = z.object({
-  kind: z.string(),
-  state: z.enum(['active', 'default', 'off']),
-  plugin: z.string().nullable(),
-  detail: z.string(),
-});
-export const kindStatusList = z.array(kindStatus);
+export const kindStatus = openapi.kindStatus;
+export const kindStatusList = openapi.systemKindsListing;
 export type KindStatus = z.infer<typeof kindStatus>;
 
 /**
@@ -32,25 +27,13 @@ export type KindStatus = z.infer<typeof kindStatus>;
  */
 export const toolExtensionsApplyResult = reloadConfigResult;
 export type ToolExtensionsApplyResult = z.infer<typeof toolExtensionsApplyResult>;
-// `GET /api/mcp-status` — the bound-server map plus the servers the viability check
-// skipped. Each failed entry adds the coarse, credential-free failure detail the
-// platform records: `category` (`auth` for a 401/403, `unreachable` for a transport
-// error or timeout, `error` otherwise), the redacted `message`, and the `http_status`
-// the failure carried (`null` for a pure transport failure). The three detail fields
-// are optional so a server that omits them still parses; plain (non-strict) objects so
-// an added field never fails the read.
-export const mcpStatus = z.object({
-  bound: z.record(z.string(), z.array(z.string())),
-  failed: z.array(
-    z.object({
-      title: z.string(),
-      status: z.string(),
-      category: z.string().optional(),
-      message: z.string().optional(),
-      http_status: z.number().nullable().optional(),
-    }),
-  ),
-});
+// `GET /api/mcp-status` — the bound-server map, the servers the viability check
+// skipped, and each server's health record. Each failed entry carries the coarse,
+// credential-free failure detail the platform records: `category` (`auth` for a 401/403,
+// `unreachable` for a transport error or timeout, `error` otherwise), the redacted
+// `message`, and the `http_status` the failure carried (`null` for a pure transport
+// failure).
+export const mcpStatus = openapi.mcpStatusSnapshot;
 
 /**
  * `POST /api/mcp-status/{title}/reload` — re-probe a single MCP server and broadcast

package/src/schemas/templates.ts

@@ -1,12 +1,10 @@
 /** Prompt-template listing, render and mutation ack schemas. */
-import { z } from 'zod';
+import * as openapi from '../generated/openapi-schemas';
 
-import { jsonSchema } from './shared';
-
-export const templateNames = z.array(z.string());
-export const templateDetail = z.object({ template: z.string(), schema: jsonSchema });
-export const templateUploaded = z.object({ path: z.string(), uploaded: z.literal(true) });
-export const templateDeleted = z.object({ path: z.string(), deleted: z.literal(true) });
-export const templateDirDeleted = z.object({ path: z.string(), deleted: z.literal(true) });
-export const templateRendered = z.object({ rendered: z.string() });
-export const templateCacheCleared = z.object({ cleared: z.literal(true) });
+export const templateNames = openapi.stringListResponse;
+export const templateDetail = openapi.templateFetchView;
+export const templateUploaded = openapi.templateUploadResult;
+export const templateDeleted = openapi.templateDeleteResult;
+export const templateDirDeleted = openapi.templateDeleteResult;
+export const templateRendered = openapi.renderedTemplate;
+export const templateCacheCleared = openapi.cacheClearResult;

package/src/schemas/tool-meta.ts

@@ -1,16 +1,14 @@
 /** Tool-organization overlay (folders and per-tool meta) schemas. */
-import { z } from 'zod';
+import type { z } from 'zod';
+
+import * as openapi from '../generated/openapi-schemas';
 
 /**
  * One folder in the tool-organization tree (`tool_folders`). `parent_id` is `null`
  * for a root folder and otherwise the containing folder's `id`; nesting is endless
  * via the parent chain. Ids are UUID strings. A drift throws `ApiSchemaError`.
  */
-export const folderRecord = z.object({
-  id: z.string(),
-  name: z.string(),
-  parent_id: z.string().nullable(),
-});
+export const folderRecord = openapi.folderRecord;
 export type FolderRecord = z.infer<typeof folderRecord>;
 
 /**
@@ -23,14 +21,7 @@ export type FolderRecord = z.infer<typeof folderRecord>;
  * `null` = defer to the plugin declaration, `true` = force hidden, `false` = force
  * visible. A drift throws `ApiSchemaError`.
  */
-export const toolMetaRecord = z.object({
-  tool_name: z.string(),
-  display_name: z.string().nullable(),
-  folder_id: z.string().nullable(),
-  tags: z.array(z.string()),
-  badges: z.array(z.string()),
-  hidden: z.boolean().nullable(),
-});
+export const toolMetaRecord = openapi.toolMetaRecord;
 export type ToolMetaRecord = z.infer<typeof toolMetaRecord>;
 
 /**
@@ -38,14 +29,11 @@ export type ToolMetaRecord = z.infer<typeof toolMetaRecord>;
  * every per-tool row. The UI builds the tree and merges the rows against the live
  * tool list client-side. A drift throws `ApiSchemaError`.
  */
-export const toolMetaOverlay = z.object({
-  folders: z.array(folderRecord),
-  meta: z.array(toolMetaRecord),
-});
+export const toolMetaOverlay = openapi.toolMetaListView;
 export type ToolMetaOverlay = z.infer<typeof toolMetaOverlay>;
 
 /** `DELETE /api/tool-meta/tools/{tool_name}` — the dropped overlay row (idempotent). */
-export const toolMetaDeleted = z.object({ tool_name: z.string(), deleted: z.literal(true) });
+export const toolMetaDeleted = openapi.toolMetaDeleted;
 
 /** `DELETE /api/tool-meta/folders/{folder_id}` — the removed empty folder. */
-export const folderDeleted = z.object({ folder_id: z.string(), deleted: z.literal(true) });
+export const folderDeleted = openapi.folderDeleted;