@tai42/api-client 14.0.0 → 16.0.0

package/src/generated/served-schemas.ts

@@ -0,0 +1,126 @@
+// DO NOT EDIT — generated from the platform contract JSON-schema bundle.
+// Source: packages/api-client/contract-schema/contract-schema.json
+// Regenerate with: pnpm --filter @tai42/api-client run schema:generate
+//
+// One zod const + inferred type per published served document and per shared
+// sub-shape. A templated-text field is the shared `templatedText` zod, never a
+// bare string, so a body can never drift back to `z.string()`.
+import { z } from 'zod';
+
+import { templatedText } from '../templated-text';
+
+export const hookSubject = z.object({ "key_expr": templatedText, "kind": z.string(), "target_kind": z.enum(["agent","tool"]), "target_name": z.string().min(1) }).strict();
+export type HookSubject = z.infer<typeof hookSubject>;
+
+export const mediaKind = z.enum(["image","link","document","video","audio"]);
+export type MediaKind = z.infer<typeof mediaKind>;
+
+export const mediaItem = z.object({ "caption": z.union([z.string(), z.null()]).default(null), "filename": z.union([z.string(), z.null()]).default(null), "kind": mediaKind, "url": z.string() });
+export type MediaItem = z.infer<typeof mediaItem>;
+
+export const presetSeedToolMeta = z.object({ "display_name": z.union([z.string(), z.null()]).default(null), "folder_path": z.union([z.string(), z.null()]).default(null), "tags": z.union([z.array(z.string()), z.null()]).default(null) });
+export type PresetSeedToolMeta = z.infer<typeof presetSeedToolMeta>;
+
+export const presetSpec = z.object({ "base_tool": z.string(), "description": z.string().default(""), "fixed_kwargs": z.record(z.string(), z.unknown()).default({}), "name": z.string() });
+export type PresetSpec = z.infer<typeof presetSpec>;
+
+export const quickReplyButtonParam = z.object({ "kind": z.literal("quick_reply").default("quick_reply"), "payload": z.string() });
+export type QuickReplyButtonParam = z.infer<typeof quickReplyButtonParam>;
+
+export const stateInjection = z.object({ "into": z.string().min(1), "jq": z.union([templatedText, z.null()]).default(null), "template_jq": z.union([z.string(), z.null()]).default(null) }).strict();
+export type StateInjection = z.infer<typeof stateInjection>;
+
+export const stateUpdate = z.object({ "adapter": z.union([templatedText, z.null()]).default(null), "jq": z.union([templatedText, z.null()]).default(null), "op_id": z.union([templatedText, z.null()]).default(null), "template_jq": z.union([z.string(), z.null()]).default(null) }).strict();
+export type StateUpdate = z.infer<typeof stateUpdate>;
+
+export const stateAttach = z.object({ "input_injections": z.array(stateInjection).default([]), "scope_expr": z.union([templatedText, z.null()]).default(null), "state": z.string(), "subject_expr": templatedText, "templates": z.array(z.string()).default([]), "updates": z.array(stateUpdate).default([]) }).strict();
+export type StateAttach = z.infer<typeof stateAttach>;
+
+export const stateBinding = z.object({ "states": z.array(stateAttach).min(1) }).strict();
+export type StateBinding = z.infer<typeof stateBinding>;
+
+export const stateTemplateDeclarations = z.object({ "check": z.union([templatedText, z.null()]).default(null), "schema": z.record(z.string(), z.unknown()) }).strict();
+export type StateTemplateDeclarations = z.infer<typeof stateTemplateDeclarations>;
+
+export const stateTemplateJq = z.object({ "description": z.string().default(""), "jq": templatedText, "params": z.array(z.string()).default([]), "purpose": z.enum(["input","update"]), "reads": z.array(z.array(z.string())).default([]), "writes": z.array(z.array(z.string())).default([]) }).strict();
+export type StateTemplateJq = z.infer<typeof stateTemplateJq>;
+
+export const stateTemplateReconcile = z.object({ "close": templatedText, "orphans": templatedText, "resolutions": templatedText }).strict();
+export type StateTemplateReconcile = z.infer<typeof stateTemplateReconcile>;
+
+export const subAgentSpec: z.ZodType = z.lazy(() => z.object({ "description": z.string().default(""), "inline_skills": z.array(z.record(z.string(), z.unknown())).default([]), "name": z.string(), "presets": z.array(presetSpec).default([]), "response_format": z.union([z.unknown(), templatedText, z.record(z.string(), z.unknown()), z.null()]).default(null), "skills": z.array(z.string()).default([]), "strategy": z.union([z.string(), z.null()]).default(null), "subagents": z.array(subAgentSpec).default([]), "system_prompt": z.union([templatedText, z.null()]).default(null), "tool_names": z.array(z.string()).default([]), "tools": z.array(z.unknown()).default([]) }));
+export type SubAgentSpec = z.infer<typeof subAgentSpec>;
+
+export const urlButtonParam = z.object({ "kind": z.literal("url").default("url"), "url_parameter": z.string() });
+export type UrlButtonParam = z.infer<typeof urlButtonParam>;
+
+export const accessPolicy = z.object({ "condition": z.union([templatedText, z.null()]).default(null), "policy_data": z.record(z.string(), z.unknown()).default({}), "scopes": z.array(z.string()).default([]) });
+export type AccessPolicy = z.infer<typeof accessPolicy>;
+
+export const callbackSchema = z.object({ "condition": z.union([templatedText, z.null()]).default(null), "expr": z.union([templatedText, z.null()]).default(null), "tool": z.string().default("") });
+export type CallbackSchema = z.infer<typeof callbackSchema>;
+
+export const channelTemplate = z.object({ "body_parameters": z.array(z.string()).default([]), "buttons": z.array(z.unknown().superRefine((x, ctx) => {
+    const schemas = [quickReplyButtonParam, urlButtonParam];
+    const { errors, failed } = schemas.reduce<{
+      errors: z.core.$ZodIssue[];
+      failed: number;
+    }>(
+      ({ errors, failed }, schema) =>
+        ((result) =>
+          result.error
+            ? {
+                errors: [...errors, ...result.error.issues],
+                failed: failed + 1,
+              }
+            : { errors, failed })(
+          schema.safeParse(x),
+        ),
+      { errors: [], failed: 0 },
+    );
+    const passed = schemas.length - failed;
+    if (passed !== 1) {
+      ctx.addIssue(errors.length ? {
+        path: [],
+        code: "invalid_union",
+        errors: [errors],
+        message: "Invalid input: Should pass single schema. Passed " + passed,
+      } : {
+        path: [],
+        code: "custom",
+        errors: [errors],
+        message: "Invalid input: Should pass single schema. Passed " + passed,
+      });
+    }
+  })).default([]), "header_media": z.union([mediaItem, z.null()]).default(null), "language": z.string(), "name": z.string() });
+export type ChannelTemplate = z.infer<typeof channelTemplate>;
+
+export const conversationRoute = z.object({ "callback_secret": z.union([z.string(), z.null()]).default(null), "callback_url": z.union([z.string(), z.null()]).default(null), "channel": z.union([z.string(), z.null()]).default(null), "door": z.enum(["api","channel"]), "error_reply_text": z.union([z.string().min(1).max(2000), z.null()]).default(null), "execution_key": z.string().min(1), "execution_key_fingerprint": z.string().min(1), "initial_mode": z.enum(["agent","manual"]).default("agent"), "locale": z.union([z.string(), z.null()]).default(null), "our_identity": z.union([z.string(), z.null()]).default(null), "payload_expr": z.union([templatedText, z.null()]).default(null), "reply_expr": z.union([templatedText, z.null()]).default(null), "route_name": z.string(), "target_kind": z.enum(["agent","tool"]), "target_name": z.string().min(1), "turns_per_hour_override": z.union([z.number().int().gt(0), z.null()]).default(null) });
+export type ConversationRoute = z.infer<typeof conversationRoute>;
+
+export const conversationRouteCreate = z.object({ "callback_url": z.union([z.string(), z.null()]).default(null), "channel": z.union([z.string(), z.null()]).default(null), "door": z.enum(["api","channel"]), "error_reply_text": z.union([z.string().min(1).max(2000), z.null()]).default(null), "execution_key": z.string().min(1), "initial_mode": z.enum(["agent","manual"]).default("agent"), "locale": z.union([z.string(), z.null()]).default(null), "our_identity": z.union([z.string(), z.null()]).default(null), "payload_expr": z.union([templatedText, z.null()]).default(null), "reply_expr": z.union([templatedText, z.null()]).default(null), "route_name": z.string(), "target_kind": z.enum(["agent","tool"]), "target_name": z.string().min(1), "turns_per_hour_override": z.union([z.number().int().gt(0), z.null()]).default(null) });
+export type ConversationRouteCreate = z.infer<typeof conversationRouteCreate>;
+
+export const hookParams = z.object({ "condition": z.union([templatedText, z.null()]).default(null), "execution_key": z.string().min(1), "execution_key_fingerprint": z.string().min(1), "expr": z.union([templatedText, z.null()]).default(null), "name": z.string().min(1), "state_binding": z.union([stateBinding, z.null()]).default(null), "subject": z.union([hookSubject, z.null()]).default(null), "tool": z.string().min(1), "tool_kwargs": z.record(z.string(), z.unknown()).default({}), "topic": z.string().min(1) });
+export type HookParams = z.infer<typeof hookParams>;
+
+export const hookRegister = z.object({ "condition": z.union([templatedText, z.null()]).default(null), "execution_key": z.string().min(1), "expr": z.union([templatedText, z.null()]).default(null), "name": z.string().min(1), "state_binding": z.union([stateBinding, z.null()]).default(null), "subject": z.union([hookSubject, z.null()]).default(null), "tool": z.string().min(1), "tool_kwargs": z.record(z.string(), z.unknown()).default({}), "topic": z.string().min(1) });
+export type HookRegister = z.infer<typeof hookRegister>;
+
+export const presetBody = z.object({ "base_tool": z.string(), "description": z.string().default(""), "extensions": z.array(z.array(z.union([z.string(), z.record(z.string(), z.unknown())]))).default([]), "fixed_kwargs": z.record(z.string(), z.unknown()).default({}), "input_schema": z.union([templatedText, z.record(z.string(), z.unknown()), z.null()]).default(null), "output_schema": z.union([templatedText, z.record(z.string(), z.unknown()), z.null()]).default(null), "state_binding": z.union([stateBinding, z.null()]).default(null) });
+export type PresetBody = z.infer<typeof presetBody>;
+
+export const presetSeed = z.object({ "base_tool": z.string(), "description": z.string(), "fixed_kwargs": z.record(z.string(), z.unknown()).default({}), "input_schema": z.union([templatedText, z.record(z.string(), z.unknown()), z.null()]).default(null), "name": z.string(), "output_schema": z.union([templatedText, z.record(z.string(), z.unknown()), z.null()]).default(null), "state_binding": z.union([stateBinding, z.null()]).default(null), "tool_meta": z.union([presetSeedToolMeta, z.null()]).default(null) });
+export type PresetSeed = z.infer<typeof presetSeed>;
+
+export const roleDefinition = z.object({ "allow_all": z.boolean().default(false), "base_tier": z.union([z.string(), z.null()]).default(null), "condition": z.union([templatedText, z.null()]).default(null), "description": z.string(), "grants": z.record(z.string(), z.enum(["none","read","write"])), "name": z.string(), "scopes": z.array(z.string()).default([]) });
+export type RoleDefinition = z.infer<typeof roleDefinition>;
+
+export const stateDeclaration = z.object({ "default_subject_kind": z.string(), "description": z.string().default(""), "effective_schema": z.union([z.record(z.string(), z.unknown()), z.null()]).default(null), "name": z.string(), "regimes": z.union([z.array(z.record(z.string(), z.unknown())), z.null()]).default(null), "retention_days": z.union([z.number().int().gt(0).lte(2147483647), z.null()]).default(null), "schema": z.union([templatedText, z.record(z.string(), z.unknown())]).optional(), "subject_kinds": z.array(z.string()).min(1), "updated_at": z.union([z.string().datetime({ offset: true }), z.null()]).default(null) }).strict();
+export type StateDeclaration = z.infer<typeof stateDeclaration>;
+
+export const stateTemplateDocument = z.object({ "declarations": z.union([stateTemplateDeclarations, z.null()]).default(null), "description": z.string().default(""), "kind": z.literal("state-template").default("state-template"), "name": z.string(), "parameters": z.record(z.string(), z.unknown()).default({}), "reconcile": z.union([stateTemplateReconcile, z.null()]).default(null), "regimes": z.array(z.record(z.string(), z.unknown())).default([]), "schema": z.union([templatedText, z.record(z.string(), z.unknown())]).optional(), "template_jq": z.union([z.record(z.string(), stateTemplateJq), z.null()]).default(null), "trace": z.record(z.string(), z.unknown()).default({}) }).strict();
+export type StateTemplateDocument = z.infer<typeof stateTemplateDocument>;
+
+export const targetConversationConfig = z.object({ "greeting_template": z.union([z.string(), z.null()]).default(null), "multichannel": z.boolean().default(false), "state_binding": z.union([stateBinding, z.null()]).default(null), "target_kind": z.enum(["agent","tool"]), "target_name": z.string().min(1) });
+export type TargetConversationConfig = z.infer<typeof targetConversationConfig>;

package/src/index.ts

@@ -86,6 +86,7 @@ export type {
 } from './fleet-report';
 export * as schemas from './schemas';
 export type {
+  TemplatedText,
   ToolSchema,
   ToolMediaResult,
   ToolTagEntry,
@@ -114,6 +115,7 @@ export type {
   StateStats,
   TemplateJq,
   TemplateReconcile,
+  TemplateDeclarations,
   StateTemplateDocument,
   StateTemplateListItem,
   StateInjection,
@@ -205,6 +207,7 @@ export type {
   Notifications,
   ChannelTemplate,
   HookParams,
+  HookRegister,
   HookSubject,
   HookList,
   TriggerAuth,

package/src/schemas.ts

@@ -6,6 +6,55 @@
  */
 import { z } from 'zod';
 
+import { templatedText } from './templated-text';
+import * as generated from './generated/served-schemas';
+
+export { templatedText, requiredTemplatedText } from './templated-text';
+export type { TemplatedText } from './templated-text';
+
+// Served-document schemas are GENERATED from the platform contract JSON-schema
+// bundle (src/generated/served-schemas.ts) and re-exported here under the names the
+// rest of the client uses. The generator maps every `x-tai42-templated-text` field
+// to the shared `templatedText` zod, so a served body can never be a bare string.
+// The plain response DTOs below (list wrappers, acks, version rows) stay hand-written.
+export const stateInjection = generated.stateInjection;
+export type StateInjection = z.infer<typeof stateInjection>;
+export const stateUpdate = generated.stateUpdate;
+export type StateUpdate = z.infer<typeof stateUpdate>;
+export const stateAttach = generated.stateAttach;
+export type StateAttach = z.infer<typeof stateAttach>;
+export const stateBinding = generated.stateBinding;
+export type StateBinding = z.infer<typeof stateBinding>;
+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 conversationRouteCreate = generated.conversationRouteCreate;
+export type ConversationRouteCreate = z.input<typeof conversationRouteCreate>;
+export const targetConversationConfig = generated.targetConversationConfig;
+export type TargetConversationConfig = z.input<typeof targetConversationConfig>;
+export const channelTemplate = generated.channelTemplate;
+export type ChannelTemplate = z.infer<typeof channelTemplate>;
+export const hookSubject = generated.hookSubject;
+export type HookSubject = z.infer<typeof hookSubject>;
+export const hookParams = generated.hookParams;
+export type HookParams = z.infer<typeof hookParams>;
+export const hookRegister = generated.hookRegister;
+export type HookRegister = z.input<typeof hookRegister>;
+export const stateDeclaration = generated.stateDeclaration;
+export type StateDeclaration = z.infer<typeof stateDeclaration>;
+export const stateTemplateDocument = generated.stateTemplateDocument;
+export type StateTemplateDocument = z.infer<typeof stateTemplateDocument>;
+export const templateJq = generated.stateTemplateJq;
+export type TemplateJq = z.infer<typeof templateJq>;
+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 policyBody = generated.accessPolicy;
+export type PolicyBody = z.infer<typeof policyBody>;
+export const roleBody = generated.roleDefinition;
+export type RoleBody = z.infer<typeof roleBody>;
 /** An arbitrary JSON value (tool results, rendered payloads). */
 export const jsonValue: z.ZodType = z.unknown();
 
@@ -149,89 +198,6 @@ export const presetDetail = presetRecord.extend({
 });
 export type PresetDetail = z.infer<typeof presetDetail>;
 
-/**
- * One input injection of a state binding: BEFORE the run, a value is produced and
- * placed into the run input under `into` (the run-input field name). A template
- * `input` jq (`template_jq`, named `name` or attachment-qualified `template.name`) reads the
- * record — its input is the record (`.`), with declared params bound as `$params`; a
- * custom `jq` reads `{record, input}` → the value. Exactly one of `template_jq`/`jq`
- * carries the program; the other is `null`.
- */
-export const stateInjection = z.object({
-  template_jq: z.string().nullable().default(null),
-  jq: z.string().nullable().default(null),
-  into: z.string(),
-});
-export type StateInjection = z.infer<typeof stateInjection>;
-
-/**
- * One update of a state binding: AFTER the run, a template-relative op batch is
- * applied through the store. A NAMED update (`template_jq`) runs the template `update`
- * jq over `{record, input}` where `input` is built by `adapter` — a jq over
- * `{output, input}` that constructs the update jq's declared input object. A custom
- * `jq` runs over `{record, output, input}` → `[{op, path, value}]` and carries no
- * adapter. `op_id` is an optional idempotency-key expression. Exactly one of
- * `template_jq`/`jq` carries the program.
- */
-export const stateUpdate = z.object({
-  template_jq: z.string().nullable().default(null),
-  jq: z.string().nullable().default(null),
-  // A named update's adapter is either a non-empty jq or `null` (no adapter — the
-  // run input passes through). `min(1)` makes the empty string impossible to
-  // round-trip: the platform compile-checks any non-null adapter and refuses `''`.
-  adapter: z.string().min(1).nullable().default(null),
-  op_id: z.string().nullable().default(null),
-});
-export type StateUpdate = z.infer<typeof stateUpdate>;
-
-/**
- * One attached state of a binding: the `state`, one or more `templates`
- * (attach-on-use — attached to the state on the binding's save), the `subject_expr`
- * (a jq yielding the record KEY — a bare key string OR a full subject object — that
- * this binding reads and updates), an optional `scope_expr` (a boolean jq predicate;
- * when it is false this state is skipped for the run), and the ordered
- * `input_injections` (before the run) and `updates` (after it).
- */
-export const stateAttach = z.object({
-  state: z.string(),
-  templates: z.array(z.string()).default([]),
-  // The platform contract enforces a non-empty subject (min_length=1); an empty
-  // expression is rejected here, never sent for the server to refuse.
-  subject_expr: z.string().min(1),
-  scope_expr: z.string().nullable().default(null),
-  input_injections: z.array(stateInjection).default([]),
-  updates: z.array(stateUpdate).default([]),
-});
-export type StateAttach = z.infer<typeof stateAttach>;
-
-/**
- * The one generic binding shape carried, optionally, on every runnable definition
- * (a preset, a channel route, a schedule, a hook) and repeated per node by the
- * flow engine. It attaches one or more states, each with its templates, subject,
- * injections and updates. `null` on a definition means no binding. Mirrors the
- * platform `StateBinding` document.
- */
-export const stateBinding = z.object({
-  // At least one attached state: the platform contract refuses a zero-state binding, so
-  // "no binding" is spelled `null` on the definition, never `{ states: [] }`.
-  states: z.array(stateAttach).min(1),
-});
-export type StateBinding = z.infer<typeof stateBinding>;
-
-/** The full version body a preset stores under `kind="preset"`. */
-export const presetBody = z.object({
-  base_tool: z.string(),
-  description: z.string(),
-  fixed_kwargs: z.record(z.string(), z.unknown()),
-  extensions: presetExtensions,
-  output_schema: z.record(z.string(), z.unknown()).nullable(),
-  input_schema: z.record(z.string(), z.unknown()).nullable(),
-  // The optional door-layer state binding this preset applies around every run
-  // (`null` when the preset touches no state).
-  state_binding: stateBinding.nullable().default(null),
-});
-export type PresetBody = z.infer<typeof presetBody>;
-
 /**
  * One immutable version row (`GET /api/presets/{name}/versions[/{version}]`).
  * `is_current` flags the active version; `tags` here is the GENERIC per-version
@@ -1192,74 +1158,12 @@ export type ConversationAnswerStatus = z.infer<typeof conversationAnswerStatus>;
 export const conversationRecordOrigin = z.enum(['client', 'operator']);
 export type ConversationRecordOrigin = z.infer<typeof conversationRecordOrigin>;
 
-/**
- * A stored routing row as a read door returns it, its `callback_secret` withheld.
- *
- * `initial_mode`, `turns_per_hour_override`, and `error_reply_text` carry defaults
- * because a stored row always returns them, while a hand-built stub/fixture may
- * omit them — the default keeps such a payload valid without inventing a field the
- * server never sends.
- */
-export const conversationRoute = z.object({
-  route_name: z.string(),
-  door: conversationDoor,
-  target_kind: conversationTargetKind,
-  target_name: z.string(),
-  payload_expr: z.string().nullable(),
-  reply_expr: z.string().nullable(),
-  initial_mode: conversationMode.default('agent'),
-  execution_key: z.string(),
-  channel: z.string().nullable(),
-  our_identity: z.string().nullable(),
-  callback_url: z.string().nullable(),
-  turns_per_hour_override: z.number().int().nullable().default(null),
-  error_reply_text: z.string().nullable().default(null),
-  execution_key_fingerprint: z.string(),
-  // The door-layer state binding the backend stores on the route's target config and
-  // returns on read (`null` when the route touches no state) — the edit form prefills it.
-  state_binding: stateBinding.nullable().default(null),
-});
-export type ConversationRoute = z.infer<typeof conversationRoute>;
-
 export const conversationRoutes = z.object({
   items: z.array(conversationRoute),
   total: z.number(),
 });
 export type ConversationRoutes = z.infer<typeof conversationRoutes>;
 
-/**
- * The client-facing create/edit body for a conversation route — the wire model of
- * `tai42_contract.conversations.ConversationRouteCreate`. `POST
- * /api/conversations/{route_name}` is an UPSERT, so this one shape is both the
- * create AND the edit body. `route_name` rides the URL path; it is carried here too
- * (the door rejects a body whose `route_name` disagrees with the path).
- *
- * The contract's cross-field validators are mirrored where the form authors this
- * body: `payload_expr`/`reply_expr` are tool-only; an `api` door carries a
- * `callback_url` (and no channel identity); a `channel` door carries `channel` +
- * `our_identity` (and no callback). Sent explicitly (including `null`) so an edit
- * clears a field the operator emptied rather than leaving the stored value.
- */
-export const conversationRouteCreate = z.object({
-  route_name: z.string(),
-  door: conversationDoor,
-  target_kind: conversationTargetKind,
-  target_name: z.string().min(1),
-  payload_expr: z.string().nullable().default(null),
-  reply_expr: z.string().nullable().default(null),
-  initial_mode: conversationMode.default('agent'),
-  execution_key: z.string().min(1),
-  channel: z.string().nullable().default(null),
-  our_identity: z.string().nullable().default(null),
-  callback_url: z.string().nullable().default(null),
-  turns_per_hour_override: z.number().int().positive().nullable().default(null),
-  error_reply_text: z.string().min(1).max(2000).nullable().default(null),
-  // The optional door-layer state binding this route applies around every turn's
-  // tool run (`null` when the route touches no state).
-  state_binding: stateBinding.nullable().default(null),
-});
-export type ConversationRouteCreate = z.infer<typeof conversationRouteCreate>;
-
 /**
  * The create/replace reply: whether THIS call created the row (vs. replaced an
  * existing one), the row itself (its `callback_secret` withheld), and the
@@ -1388,28 +1292,6 @@ export const conversationThreadMessageSent = z.object({
 });
 export type ConversationThreadMessageSent = z.infer<typeof conversationThreadMessageSent>;
 
-/**
- * Per-target presentation config for the conversation bridge, keyed by
- * `(target_kind, target_name)` — the wire model of
- * `tai42_contract.conversations.TargetConversationConfig`. The row carries no
- * server-derived fields, so this ONE shape is the stored row AND the upsert body
- * (`PUT /api/conversation-configs/{target_kind}/{target_name}` is the create AND
- * the edit path).
- *
- * `multichannel` opts the target into person linking; `greeting_template` is the
- * first-contact greeting. `greeting_template` is a `str.format` template (NOT a jq
- * expression) that may reference at most the `{pairing_code}` placeholder — it
- * carries no `x-tai42-expression`. `null` is the explicit spelling for "no
- * greeting"; a blank string is refused server-side.
- */
-export const targetConversationConfig = z.object({
-  target_kind: conversationTargetKind,
-  target_name: z.string().min(1),
-  multichannel: z.boolean().default(false),
-  greeting_template: z.string().nullable().default(null),
-});
-export type TargetConversationConfig = z.infer<typeof targetConversationConfig>;
-
 /** Every stored per-target config (`GET /api/conversation-configs`). */
 export const conversationConfigs = z.object({
   items: z.array(targetConversationConfig),
@@ -1530,19 +1412,6 @@ export type WebEntryCodeRevoked = z.infer<typeof webEntryCodeRevoked>;
 // send), `options` (tappable option labels) — plus the `audience` identity the
 // record is addressed to; the inbox renders them.
 
-/**
- * A pre-approved channel template a notification carried, stored raw on the sink
- * record when the notify supplied one (server-side it is mutually exclusive with
- * `media`/`options`). `parameters` is the POSITIONAL list of body-text values
- * substituted into the template's placeholders in order; empty when it has none.
- */
-export const channelTemplate = z.object({
-  name: z.string(),
-  language: z.string(),
-  parameters: z.array(z.string()).default([]),
-});
-export type ChannelTemplate = z.infer<typeof channelTemplate>;
-
 export const notification = z.object({
   id: z.string(),
   message: z.string(),
@@ -1575,9 +1444,10 @@ export const notifications = z.object({
 export type Notifications = z.infer<typeof notifications>;
 
 // -- hooks -------------------------------------------------------------------
-// Shapes match tai42_contract.hooks.HookParams: a hook fires a `tool` on a `topic`,
-// optionally gated by a `condition` and shaped by an `expr` (each either an inline
-// spec or a registered id, with its own kwargs).
+// The hand-written hook response DTOs: the fire-door authority enum, the list rows and
+// their wrapper, and the per-topic verifier/trigger metadata. The served hook DOCUMENT
+// schemas (`hookSubject`/`hookParams`/`hookRegister`) are generated from the contract
+// bundle and re-exported at the top of this file, not defined here.
 
 /** A fire door — who may trigger a path, not what the fire may do. A string enum. */
 export const triggerAuth = z.enum([
@@ -1589,44 +1459,6 @@ export const triggerAuth = z.enum([
 ]);
 export type TriggerAuth = z.infer<typeof triggerAuth>;
 
-/**
- * The optional state subject a hook fire targets (mirrors
- * `tai42_contract.hooks.HookSubject`): the conversation-target scope plus the subject
- * `kind` and a `key_expr` jq evaluated over the event payload at fire. `null` leaves the
- * fire with no ambient state context.
- */
-export const hookSubject = z.object({
-  target_kind: conversationTargetKind,
-  target_name: z.string(),
-  kind: z.string(),
-  key_expr: z.string(),
-});
-export type HookSubject = z.infer<typeof hookSubject>;
-
-export const hookParams = z.object({
-  name: z.string(),
-  topic: z.string(),
-  tool: z.string(),
-  // The api-key `user_id` the fire runs AS.
-  execution_key: z.string().min(1),
-  tool_kwargs: z.record(z.string(), z.unknown()).default({}),
-  // The optional state subject the fire targets; `null` leaves it with no ambient
-  // state context (a state tool it calls must then carry an explicit subject).
-  subject: hookSubject.nullable().default(null),
-  condition: z.string().nullable().default(null),
-  condition_id: z.string().nullable().default(null),
-  // The `*_kwargs` pair is non-optional in the contract (defaults to {}, never
-  // null) — unlike the sibling condition/expr string fields, which are nullable.
-  condition_kwargs: z.record(z.string(), z.unknown()).default({}),
-  expr: z.string().nullable().default(null),
-  expr_id: z.string().nullable().default(null),
-  expr_kwargs: z.record(z.string(), z.unknown()).default({}),
-  // The optional door-layer state binding this hook applies around its fire's tool
-  // run (`null` when the hook touches no state).
-  state_binding: stateBinding.nullable().default(null),
-});
-export type HookParams = z.infer<typeof hookParams>;
-
 export const hookList = z.object({
   items: z.array(hookParams),
   total: z.number(),
@@ -1797,26 +1629,6 @@ export type GrantLevel = z.infer<typeof grantLevel>;
 export const roleGrants = z.record(z.string(), grantLevel);
 export type RoleGrants = z.infer<typeof roleGrants>;
 
-/**
- * A role body (`GET /api/auth/roles`, and the write routes' echo). Layer 1 is the
- * read-only base-tier ceiling — the seeded jq `condition` plus `base_tier`
- * (`editor`/`viewer`, or `null` for the reserved `allow_all` admin). Layer 2 is the
- * editable per-tag `grants` map. `allow_all` (admin) carries an empty `grants` map
- * and reaches everything, un-lockable. `condition`/`condition_id`/`condition_kwargs`
- * are the base-tier jq — READ-ONLY here (no raw-jq authoring surface).
- */
-export const roleBody = z.object({
-  name: z.string(),
-  description: z.string(),
-  scopes: z.array(z.string()),
-  condition: z.string().nullable(),
-  condition_id: z.string().nullable(),
-  condition_kwargs: jsonValue.nullable(),
-  base_tier: z.string().nullable(),
-  allow_all: z.boolean(),
-  grants: roleGrants,
-});
-export type RoleBody = z.infer<typeof roleBody>;
 export const roleList = z.array(roleBody);
 
 /** `DELETE /api/auth/roles/{name}` — the deleted role's name. */
@@ -1879,9 +1691,7 @@ export const tokensPayload = z.array(
     description: z.string(),
     scopes: z.array(z.string()),
     policy_data: jsonValue,
-    condition: z.string().nullable().optional(),
-    condition_id: z.string().nullable().optional(),
-    condition_kwargs: jsonValue.nullable().optional(),
+    condition: templatedText.nullable().optional(),
   }),
 );
 export type TokensPayload = z.infer<typeof tokensPayload>;
@@ -2058,21 +1868,6 @@ export const validateConditionResult = z.object({
 });
 export type ValidateConditionResult = z.infer<typeof validateConditionResult>;
 
-/**
- * The enforced policy shape a version body carries. SECRET-ADJACENT — `condition`
- * can reveal auth logic, so its fixtures are hand-authored, never captured.
- * `condition`/`condition_id` are mutually exclusive at author time; both are
- * nullable here because whichever mode is unused is stored as `null`.
- */
-export const policyBody = z.object({
-  scopes: z.array(z.string()),
-  policy_data: jsonValue,
-  condition: z.string().nullable(),
-  condition_id: z.string().nullable(),
-  condition_kwargs: jsonValue.nullable(),
-});
-export type PolicyBody = z.infer<typeof policyBody>;
-
 /**
  * One immutable policy version row
  * (`GET /api/auth/api-keys/{user_id}/policy/versions`). `is_current` flags the
@@ -2696,12 +2491,13 @@ export type MarketplaceUninstallResult = z.infer<typeof marketplaceUninstallResu
 export { toolRunSubmitResult, toolRunRecord, toolRunList } from './tool-runs';
 
 // -- states ------------------------------------------------------------------
-// Shapes mirror tai42_contract.states.models: a declared JSON document, one per
-// subject. The base document, template fragments, write regimes and effective schema
-// are permissive JSON records — the auto-form and JsonTree interpret them at runtime;
-// a drift throws ApiSchemaError. Server-composed fields (`effective_schema`, `regimes`,
-// list/stats derived columns) are modelled optional so a response that omits them still
-// parses.
+// 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.
 
 /** One addressed subject: the conversation-target scope plus the (kind, key) within it. */
 export const stateSubject = z.object({
@@ -2715,25 +2511,6 @@ 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());
 
-/**
- * A declared state served on every read. `schema` is the base JSON Schema;
- * `effective_schema` (the base composed with every attached template's fragment) and
- * `regimes` (the absolute write-regime rules) are platform-COMPUTED and served on every
- * read — modelled optional so a write body that omits them, or a server yet to compose
- * them, still parses. A drift throws ApiSchemaError.
- */
-export const stateDeclaration = z.object({
-  name: z.string(),
-  description: z.string().default(''),
-  schema: jsonSchema,
-  subject_kinds: z.array(z.string()),
-  default_subject_kind: z.string(),
-  retention_days: z.number().nullable().default(null),
-  effective_schema: jsonSchema.nullable().optional(),
-  regimes: z.array(stateRegime).nullable().optional(),
-});
-export type StateDeclaration = z.infer<typeof stateDeclaration>;
-
 /**
  * One row of `GET /api/states` — a served declaration (`list_states` dumps every
  * `StateDeclaration`) plus `updated_at` (the row's last-write timestamp, ISO or
@@ -2776,55 +2553,6 @@ export const stateStats = z.object({
 });
 export type StateStats = z.infer<typeof stateStats>;
 
-/**
- * One template jq: `jq` is a program over the subject's attached subtree, its `purpose`
- * either `input` (a read-only program feeding a tool argument) or `update` (a program
- * returning an op batch that mutates the record). `params` are its declared argument
- * names; `reads`/`writes` are the template-relative record paths an `update` declares,
- * each a list of key segments; `description` is the human label.
- */
-export const templateJq = z.object({
-  description: z.string().default(''),
-  purpose: z.enum(['input', 'update']),
-  params: z.array(z.string()).default([]),
-  reads: z.array(z.array(z.string())).default([]),
-  writes: z.array(z.array(z.string())).default([]),
-  jq: z.string(),
-});
-export type TemplateJq = z.infer<typeof templateJq>;
-
-/**
- * How a declarations edit settles open records: `view` reads the record, `close`
- * builds the op batch that settles it, `resolutions` names the resolutions a close
- * may name — each a jq program.
- */
-export const templateReconcile = z.object({
-  view: z.string(),
-  close: z.string(),
-  resolutions: z.string(),
-});
-export type TemplateReconcile = z.infer<typeof templateReconcile>;
-
-/**
- * The platform half of a state-template document (mirrors StateTemplateDocument).
- * `template_jq` maps a name to its definition (each carrying its `purpose`);
- * `reconcile` is the settle policy — both optional (`null` when the template declares
- * none).
- */
-export const stateTemplateDocument = z.object({
-  kind: z.literal('state-template').default('state-template'),
-  name: z.string(),
-  description: z.string().default(''),
-  parameters: z.record(z.string(), z.unknown()).default({}),
-  schema: jsonSchema,
-  regimes: z.array(stateRegime).default([]),
-  declarations: z.record(z.string(), z.unknown()).nullable().default(null),
-  trace: z.record(z.string(), z.unknown()).default({}),
-  template_jq: z.record(z.string(), templateJq).nullable().default(null),
-  reconcile: templateReconcile.nullable().default(null),
-});
-export type StateTemplateDocument = z.infer<typeof stateTemplateDocument>;
-
 /**
  * One row of `GET /api/state-templates`. The template document plus the two derived columns
  * the Templates tab shows: `attached_to` (how many states attach it — a delete is refused