@vertesia/common 1.6.0-dev.20260923.085325Z → 1.6.0-dev.20261004.085740Z

package/src/payload.ts

@@ -1,18 +1,3 @@
-import type { z } from 'zod';
-import type {
-    ComputeCollectionFacetPayloadSchema,
-    ComputeObjectFacetPayloadSchema,
-    ExportPropertiesPayloadSchema,
-    ExportPropertiesResponseSchema,
-} from './api-schemas/content.js';
-import type {
-    ComputeInteractionFacetPayloadSchema,
-    ComputeRunFacetPayloadSchema,
-    RunSearchPayloadSchema,
-    SortOptionSchema,
-    SortOrderSchema,
-} from './api-schemas/interaction.js';
-import type { ComputePromptFacetPayloadSchema } from './api-schemas/prompt.js';
 import type { FacetSpec } from './facets.js';
 import type {
     InteractionSearchQuery,
@@ -21,10 +6,11 @@ import type {
     PromptSearchQuery,
     SimpleSearchQuery,
 } from './query.js';
+import type * as Wire from './wire-types.generated.js';
 
-export type SortOrder = z.infer<typeof SortOrderSchema>;
+export type SortOrder = Wire.SortOrder;
 
-export type SortOption = z.infer<typeof SortOptionSchema>;
+export type SortOption = Wire.SortOption;
 
 interface SearchPayload {
     facets?: FacetSpec[];
@@ -61,18 +47,18 @@ export interface PromptSearchPayload extends SearchPayload {
     query?: PromptSearchQuery;
 }
 
-export type RunSearchPayload = z.infer<typeof RunSearchPayloadSchema>;
+export type RunSearchPayload = Wire.RunSearchPayload;
 
-export type ComputeCollectionFacetPayload = z.infer<typeof ComputeCollectionFacetPayloadSchema>;
+export type ComputeCollectionFacetPayload = Wire.ComputeCollectionFacetPayload;
 
-export type ComputeInteractionFacetPayload = z.infer<typeof ComputeInteractionFacetPayloadSchema>;
+export type ComputeInteractionFacetPayload = Wire.ComputeInteractionFacetPayload;
 
-export type ComputeObjectFacetPayload = z.infer<typeof ComputeObjectFacetPayloadSchema>;
+export type ComputeObjectFacetPayload = Wire.ComputeObjectFacetPayload;
 
-export type ComputePromptFacetPayload = z.infer<typeof ComputePromptFacetPayloadSchema>;
+export type ComputePromptFacetPayload = Wire.ComputePromptFacetPayload;
 
-export type ComputeRunFacetPayload = z.infer<typeof ComputeRunFacetPayloadSchema>;
+export type ComputeRunFacetPayload = Wire.ComputeRunFacetPayload;
 
-export type ExportPropertiesPayload = z.infer<typeof ExportPropertiesPayloadSchema>;
+export type ExportPropertiesPayload = Wire.ExportPropertiesPayload;
 
-export type ExportPropertiesResponse = z.infer<typeof ExportPropertiesResponseSchema>;
+export type ExportPropertiesResponse = Wire.ExportPropertiesResponse;

package/src/pending-asks.ts

@@ -1,32 +1,18 @@
-/**
- * Types for tracking pending ask_user requests and webhook notifications.
- * Used to notify external systems when agents are waiting for user input.
- */
-
-import type { z } from 'zod';
-import type {
-    ListPendingAsksResponseSchema,
-    PendingAskDataSchema,
-    PendingAskStatusSchema,
-    RegisterPendingAskRequestSchema,
-    RegisterPendingAskResponseSchema,
-    ResolvePendingAskRequestSchema,
-    ResolvePendingAskResponseSchema,
-} from './api-schemas/agent-communication.js';
+import type * as Wire from './wire-types.generated.js';
 
 // ================= Pending Ask Data ====================
 
 /**
  * Status of a pending ask request.
  */
-export type PendingAskStatus = z.infer<typeof PendingAskStatusSchema>;
+export type PendingAskStatus = Wire.PendingAskStatus;
 
 /**
  * Data stored in Redis for pending ask_user requests.
  * Tracks which agents are waiting for user input and enables
  * both webhook notifications and portal views.
  */
-export type PendingAskData = z.infer<typeof PendingAskDataSchema>;
+export type PendingAskData = Wire.PendingAskData;
 
 // ================= Webhook Events ====================
 
@@ -81,8 +67,8 @@ export interface AskUserWebhookEvent {
 /**
  * Response from listing pending asks.
  */
-export type RegisterPendingAskRequest = z.infer<typeof RegisterPendingAskRequestSchema>;
-export type RegisterPendingAskResponse = z.infer<typeof RegisterPendingAskResponseSchema>;
-export type ResolvePendingAskRequest = z.infer<typeof ResolvePendingAskRequestSchema>;
-export type ResolvePendingAskResponse = z.infer<typeof ResolvePendingAskResponseSchema>;
-export type ListPendingAsksResponse = z.infer<typeof ListPendingAsksResponseSchema>;
+export type RegisterPendingAskRequest = Wire.RegisterPendingAskRequest;
+export type RegisterPendingAskResponse = Wire.RegisterPendingAskResponse;
+export type ResolvePendingAskRequest = Wire.ResolvePendingAskRequest;
+export type ResolvePendingAskResponse = Wire.ResolvePendingAskResponse;
+export type ListPendingAsksResponse = Wire.ListPendingAsksResponse;

package/src/platform-event.ts

@@ -1,74 +1,25 @@
-import type { z } from 'zod';
-import type { EventRefSchema } from './api-schemas/app-lifecycle.js';
-import type { EventCategorySchema } from './api-schemas/audit-trail.js';
-import type {
-    AgentDeliveryMatchModeSchema,
-    AgentEventDeliveryTargetSchema,
-    AgentSemanticEvaluatorSchema,
-    AppEventDeliveryTargetInputSchema,
-    AppEventDeliveryTargetSchema,
-    CancelEventDeliveryIntentsPayloadSchema,
-    CancelEventDeliveryIntentsResponseSchema,
-    CreateEventIngestChannelPayloadSchema,
-    EventDeliveryIntentStatusSchema,
-    EventDeliveryIntentSummarySchema,
-    EventDeliveryQueueFailureSummarySchema,
-    EventDeliveryQueueSortFieldSchema,
-    EventDeliveryQueueSubscriptionSummarySchema,
-    EventDeliveryQueueSummaryPayloadSchema,
-    EventDeliveryQueueSummaryResponseSchema,
-    EventDeliverySortFieldSchema,
-    EventDeliverySummarySchema,
-    EventIngestChannelMutationResponseSchema,
-    EventIngestChannelSchema,
-    EventIngestResourceRuleSchema,
-    EventIngestSignatureAlgorithmSchema,
-    EventIngestSignatureConfigSchema,
-    EventIngestSignatureEncodingSchema,
-    EventIngestTransformSchema,
-    EventOutboxQueueSummarySchema,
-    EventOutboxStatusSchema,
-    EventPrioritySchema,
-    EventSemanticConditionSchema,
-    EventSubscriptionFilterSchema,
-    InteractionSemanticEvaluatorSchema,
-    ListEventDeliveriesPayloadSchema,
-    ListEventDeliveriesResponseSchema,
-    SemanticConditionModeSchema,
-    SemanticConditionOnErrorSchema,
-    SemanticEvaluationRecordSchema,
-    SemanticEvaluationStatusSchema,
-    SemanticEvaluatorSchema,
-    StreamEventDeliveriesQuerySchema,
-    UpdateEventIngestChannelPayloadSchema,
-    WebhookEventDeliveryTargetInputSchema,
-    WebhookEventDeliveryTargetSchema,
-    WebhookPayloadModeSchema,
-    WebhookSigningModeSchema,
-    WorkflowEventDeliveryTargetInputSchema,
-    WorkflowEventDeliveryTargetSchema,
-} from './api-schemas/events.js';
 import type { AuditMeter } from './audit-trail.js';
 import type { ConversationVisibility } from './interaction.js';
 import type { SystemRoles } from './project.js';
 import type { ProcessDefinitionBody, ProcessRunType } from './store/index.js';
+import type * as Wire from './wire-types.generated.js';
 
 // Inferred from `./api-schemas/audit-trail.js`, which is where the schema sits: the audit trail is
 // the only place the category is published, and the converter grouped it with the endpoints that
 // publish it rather than with the event types that carry it.
-export type EventCategory = z.infer<typeof EventCategorySchema>;
+export type EventCategory = Wire.EventCategory;
 
-export type EventPriority = z.infer<typeof EventPrioritySchema>;
+export type EventPriority = Wire.EventPriority;
 
-export type WebhookSigningMode = z.infer<typeof WebhookSigningModeSchema>;
+export type WebhookSigningMode = Wire.WebhookSigningMode;
 
-export type WebhookPayloadMode = z.infer<typeof WebhookPayloadModeSchema>;
+export type WebhookPayloadMode = Wire.WebhookPayloadMode;
 
-export type EventOutboxStatus = z.infer<typeof EventOutboxStatusSchema>;
+export type EventOutboxStatus = Wire.EventOutboxStatus;
 
-export type EventDeliveryIntentStatus = z.infer<typeof EventDeliveryIntentStatusSchema>;
+export type EventDeliveryIntentStatus = Wire.EventDeliveryIntentStatus;
 
-export type EventRef = z.infer<typeof EventRefSchema>;
+export type EventRef = Wire.EventRef;
 
 export interface PlatformEvent extends EventRef {
     timestamp: string;
@@ -93,39 +44,39 @@ export interface PlatformEvent extends EventRef {
     details?: Record<string, unknown>;
 }
 
-export type EventSubscriptionFilter = z.infer<typeof EventSubscriptionFilterSchema>;
+export type EventSubscriptionFilter = Wire.EventSubscriptionFilter;
 
 // --- Semantic conditions ---
 // A semantic_condition is an LLM-evaluated natural-language predicate applied AFTER all structural
 // filters (categories, actions, resource types, JSONLogic condition) have matched.
 
-export type SemanticConditionMode = z.infer<typeof SemanticConditionModeSchema>;
+export type SemanticConditionMode = Wire.SemanticConditionMode;
 
-export type SemanticConditionOnError = z.infer<typeof SemanticConditionOnErrorSchema>;
+export type SemanticConditionOnError = Wire.SemanticConditionOnError;
 
-export type SemanticEvaluationStatus = z.infer<typeof SemanticEvaluationStatusSchema>;
+export type SemanticEvaluationStatus = Wire.SemanticEvaluationStatus;
 
-export type InteractionSemanticEvaluator = z.infer<typeof InteractionSemanticEvaluatorSchema>;
+export type InteractionSemanticEvaluator = Wire.InteractionSemanticEvaluator;
 
-export type AgentSemanticEvaluator = z.infer<typeof AgentSemanticEvaluatorSchema>;
+export type AgentSemanticEvaluator = Wire.AgentSemanticEvaluator;
 
-export type SemanticEvaluator = z.infer<typeof SemanticEvaluatorSchema>;
+export type SemanticEvaluator = Wire.SemanticEvaluator;
 
-export type EventSemanticCondition = z.infer<typeof EventSemanticConditionSchema>;
+export type EventSemanticCondition = Wire.EventSemanticCondition;
 
-export type SemanticEvaluationRecord = z.infer<typeof SemanticEvaluationRecordSchema>;
+export type SemanticEvaluationRecord = Wire.SemanticEvaluationRecord;
 
-export type WorkflowEventDeliveryTarget = z.infer<typeof WorkflowEventDeliveryTargetSchema>;
+export type WorkflowEventDeliveryTarget = Wire.WorkflowEventDeliveryTarget;
 
-export type WebhookEventDeliveryTarget = z.infer<typeof WebhookEventDeliveryTargetSchema>;
+export type WebhookEventDeliveryTarget = Wire.WebhookEventDeliveryTarget;
 
-export type AppEventDeliveryTarget = z.infer<typeof AppEventDeliveryTargetSchema>;
+export type AppEventDeliveryTarget = Wire.AppEventDeliveryTarget;
 
 export const DEFAULT_EVENT_AGENT_INTERACTION_REF = 'sys:GeneralAgent';
 
-export type AgentDeliveryMatchMode = z.infer<typeof AgentDeliveryMatchModeSchema>;
+export type AgentDeliveryMatchMode = Wire.AgentDeliveryMatchMode;
 
-export type AgentEventDeliveryTarget = z.infer<typeof AgentEventDeliveryTargetSchema>;
+export type AgentEventDeliveryTarget = Wire.AgentEventDeliveryTarget;
 
 export interface ProcessEventDeliveryTarget {
     type: 'process';
@@ -155,11 +106,11 @@ export type EventDeliveryTarget =
 // callers supply the input shapes below: server-managed fields (has_secret, secret_label,
 // migrated_rule_name) are omitted, and write-only directives (rotate_signing_secret) are added.
 
-export type WorkflowEventDeliveryTargetInput = z.infer<typeof WorkflowEventDeliveryTargetInputSchema>;
+export type WorkflowEventDeliveryTargetInput = Wire.WorkflowEventDeliveryTargetInput;
 
-export type WebhookEventDeliveryTargetInput = z.infer<typeof WebhookEventDeliveryTargetInputSchema>;
+export type WebhookEventDeliveryTargetInput = Wire.WebhookEventDeliveryTargetInput;
 
-export type AppEventDeliveryTargetInput = z.infer<typeof AppEventDeliveryTargetInputSchema>;
+export type AppEventDeliveryTargetInput = Wire.AppEventDeliveryTargetInput;
 
 export type EventDeliveryTargetInput =
     | WorkflowEventDeliveryTargetInput
@@ -229,17 +180,17 @@ export interface EventSubscriptionMutationResponse {
     webhook_signing_secret?: string;
 }
 
-export type EventDeliveryIntentSummary = z.infer<typeof EventDeliveryIntentSummarySchema>;
+export type EventDeliveryIntentSummary = Wire.EventDeliveryIntentSummary;
 
-export type EventDeliverySummary = z.infer<typeof EventDeliverySummarySchema>;
+export type EventDeliverySummary = Wire.EventDeliverySummary;
 
-export type EventDeliverySortField = z.infer<typeof EventDeliverySortFieldSchema>;
+export type EventDeliverySortField = Wire.EventDeliverySortField;
 
-export type ListEventDeliveriesPayload = z.infer<typeof ListEventDeliveriesPayloadSchema>;
+export type ListEventDeliveriesPayload = Wire.ListEventDeliveriesPayload;
 
-export type ListEventDeliveriesResponse = z.infer<typeof ListEventDeliveriesResponseSchema>;
+export type ListEventDeliveriesResponse = Wire.ListEventDeliveriesResponse;
 
-export type StreamEventDeliveriesQuery = z.infer<typeof StreamEventDeliveriesQuerySchema>;
+export type StreamEventDeliveriesQuery = Wire.StreamEventDeliveriesQuery;
 
 export interface EventDeliveryStreamItem {
     cursor: string;
@@ -325,41 +276,41 @@ export interface ListEventIngestChannelsQuery {
     sort_order?: 'asc' | 'desc';
 }
 
-export type EventDeliveryQueueSortField = z.infer<typeof EventDeliveryQueueSortFieldSchema>;
+export type EventDeliveryQueueSortField = Wire.EventDeliveryQueueSortField;
 
-export type EventDeliveryQueueSummaryPayload = z.infer<typeof EventDeliveryQueueSummaryPayloadSchema>;
+export type EventDeliveryQueueSummaryPayload = Wire.EventDeliveryQueueSummaryPayload;
 
-export type EventOutboxQueueSummary = z.infer<typeof EventOutboxQueueSummarySchema>;
+export type EventOutboxQueueSummary = Wire.EventOutboxQueueSummary;
 
-export type EventDeliveryQueueFailureSummary = z.infer<typeof EventDeliveryQueueFailureSummarySchema>;
+export type EventDeliveryQueueFailureSummary = Wire.EventDeliveryQueueFailureSummary;
 
-export type EventDeliveryQueueSubscriptionSummary = z.infer<typeof EventDeliveryQueueSubscriptionSummarySchema>;
+export type EventDeliveryQueueSubscriptionSummary = Wire.EventDeliveryQueueSubscriptionSummary;
 
-export type EventDeliveryQueueSummaryResponse = z.infer<typeof EventDeliveryQueueSummaryResponseSchema>;
+export type EventDeliveryQueueSummaryResponse = Wire.EventDeliveryQueueSummaryResponse;
 
-export type CancelEventDeliveryIntentsPayload = z.infer<typeof CancelEventDeliveryIntentsPayloadSchema>;
+export type CancelEventDeliveryIntentsPayload = Wire.CancelEventDeliveryIntentsPayload;
 
-export type CancelEventDeliveryIntentsResponse = z.infer<typeof CancelEventDeliveryIntentsResponseSchema>;
+export type CancelEventDeliveryIntentsResponse = Wire.CancelEventDeliveryIntentsResponse;
 
 // --- External event ingest channels ---
 // An ingest channel is a token-authenticated inbound endpoint that lets external systems publish
 // events into the platform event bus. Ingested events get event_category 'external' and
 // source 'external:<source>', and match event subscriptions like any other platform event.
 
-export type EventIngestResourceRule = z.infer<typeof EventIngestResourceRuleSchema>;
+export type EventIngestResourceRule = Wire.EventIngestResourceRule;
 
-export type EventIngestTransform = z.infer<typeof EventIngestTransformSchema>;
+export type EventIngestTransform = Wire.EventIngestTransform;
 
-export type EventIngestSignatureAlgorithm = z.infer<typeof EventIngestSignatureAlgorithmSchema>;
+export type EventIngestSignatureAlgorithm = Wire.EventIngestSignatureAlgorithm;
 
-export type EventIngestSignatureEncoding = z.infer<typeof EventIngestSignatureEncodingSchema>;
+export type EventIngestSignatureEncoding = Wire.EventIngestSignatureEncoding;
 
-export type EventIngestSignatureConfig = z.infer<typeof EventIngestSignatureConfigSchema>;
+export type EventIngestSignatureConfig = Wire.EventIngestSignatureConfig;
 
-export type EventIngestChannel = z.infer<typeof EventIngestChannelSchema>;
+export type EventIngestChannel = Wire.EventIngestChannel;
 
-export type CreateEventIngestChannelPayload = z.infer<typeof CreateEventIngestChannelPayloadSchema>;
+export type CreateEventIngestChannelPayload = Wire.CreateEventIngestChannelPayload;
 
-export type UpdateEventIngestChannelPayload = z.infer<typeof UpdateEventIngestChannelPayloadSchema>;
+export type UpdateEventIngestChannelPayload = Wire.UpdateEventIngestChannelPayload;
 
-export type EventIngestChannelMutationResponse = z.infer<typeof EventIngestChannelMutationResponseSchema>;
+export type EventIngestChannelMutationResponse = Wire.EventIngestChannelMutationResponse;

package/src/principal-context.ts

@@ -1,5 +1,5 @@
-import type { z } from 'zod';
-import type { AbacPrincipalContextFromSchema, PrincipalIdentitySchema } from './api-schemas/user.js';
+import type { AbacPrincipalContextFromSchema } from './api-schemas/user.js';
+import type * as Wire from './wire-types.generated.js';
 
 /**
  * The resolved principal context matched by ResourceSet/PrincipalSet condition evaluation
@@ -30,4 +30,4 @@ export type PrincipalKind = AbacPrincipalContext['kind'];
  * the identity, so a field added here never widens the `$principal.*` surface. Derived from
  * `PrincipalIdentitySchema`, where its published description lives — Zod reads `.meta()`, not TSDoc.
  */
-export type PrincipalIdentity = z.infer<typeof PrincipalIdentitySchema>;
+export type PrincipalIdentity = Wire.PrincipalIdentity;

package/src/project.ts

@@ -1,51 +1,6 @@
-import type { z } from 'zod';
-import type { ProjectRefSchema } from './api-schemas/apikey.js';
-import type {
-    EmbeddingsStatusResponseSchema,
-    ProjectConfigurationEmbeddingEnablePayloadSchema,
-} from './api-schemas/embeddings.js';
-import type {
-    DriftAnalysisProgressSchema,
-    DriftAnalysisResultSchema,
-    DriftAnalysisStatusResponseSchema,
-    IndexingStatusResponseSchema,
-    ReindexAgentRunsPayloadSchema,
-    ReindexAgentRunsResponseSchema,
-    StartProjectReindexPayloadSchema,
-} from './api-schemas/indexing.js';
-import type {
-    CreateProjectPayloadFromSchema,
-    ListProjectsQuerySchema,
-    ProjectIntegrationListEntrySchema,
-    ProjectIntegrationListResponseSchema,
-    ProjectPluginsUpdatePayloadSchema,
-    ProjectSchema,
-    ProjectTagQuerySchema,
-    UpdateProjectConfigurationPayloadSchema,
-    UpdateProjectPayloadSchema,
-} from './api-schemas/project.js';
-import type {
-    AgentCheckpointConfigurationSchema,
-    AgentProjectConfigurationSchema,
-    BrowserUseProjectConfigurationSchema,
-    BrowserUseRiskPolicySchema,
-    BrowserUseScreenshotCaptureSchema,
-    ElasticsearchBackendSchema,
-    IntakeVisionProfileSettingsUpdateSchema,
-    ModalityDefaultsSchema,
-    ModelDefaultSchema,
-    ProjectConfigurationEmbeddingSchema,
-    ProjectConfigurationSchema,
-    ProjectIndexingConfigurationSchema,
-    ProjectIntakeConfigurationSchema,
-    ProjectIntakeSniffConfigurationSchema,
-    ProjectModelDefaultsSchema,
-    ProjectSearchPropertyMappingSchema,
-    ProjectSearchPropertyTypeSchema,
-    ProjectSearchTierSchema,
-    SystemDefaultsSchema,
-} from './api-schemas/project-configuration.js';
+import type { CreateProjectPayloadFromSchema } from './api-schemas/project.js';
 import type { AccountRef } from './user.js';
+import type * as Wire from './wire-types.generated.js';
 
 /**
  * `SystemRoles` lives in `./project-values.js` so the API schemas can read it without importing this
@@ -73,19 +28,19 @@ export interface PopulatedProjectRef {
 // The `restricted` flag's explanation lives in the schema's `.meta()`, which is what the published
 // component carries; it is no longer visible as TSDoc here, the same trade every other
 // schema-derived type in this package already makes.
-export type ProjectRef = z.infer<typeof ProjectRefSchema>;
+export type ProjectRef = Wire.ProjectRef;
 
-export type ProjectTagQuery = z.infer<typeof ProjectTagQuerySchema>;
+export type ProjectTagQuery = Wire.ProjectTagQuery;
 
-export type ListProjectsQuery = z.infer<typeof ListProjectsQuerySchema>;
+export type ListProjectsQuery = Wire.ListProjectsQuery;
 
 // ==========================================
 // Project Model Defaults Types
 // ==========================================
 
-export type ModelDefault = z.infer<typeof ModelDefaultSchema>;
+export type ModelDefault = Wire.ModelDefault;
 
-export type ModalityDefaults = z.infer<typeof ModalityDefaultsSchema>;
+export type ModalityDefaults = Wire.ModalityDefaults;
 
 /**
  * System interaction category enum.
@@ -137,13 +92,13 @@ export const SYSTEM_INTERACTION_CATEGORIES: Record<string, SystemInteractionCate
  * asserts that its keys are exactly the category union — a new category has to be added in both
  * places, and fails to compile until it is.
  */
-export type SystemDefaults = z.infer<typeof SystemDefaultsSchema>;
+export type SystemDefaults = Wire.SystemDefaults;
 
-export type ProjectModelDefaults = z.infer<typeof ProjectModelDefaultsSchema>;
+export type ProjectModelDefaults = Wire.ProjectModelDefaults;
 
-export type BrowserUseRiskPolicy = z.infer<typeof BrowserUseRiskPolicySchema>;
+export type BrowserUseRiskPolicy = Wire.BrowserUseRiskPolicy;
 
-export type BrowserUseScreenshotCapture = z.infer<typeof BrowserUseScreenshotCaptureSchema>;
+export type BrowserUseScreenshotCapture = Wire.BrowserUseScreenshotCapture;
 
 /**
  * Project defaults and caps for `browser_use` agent workstreams.
@@ -152,30 +107,32 @@ export type BrowserUseScreenshotCapture = z.infer<typeof BrowserUseScreenshotCap
  * interface. Nothing read it, and its descriptions had already drifted from the TSDoc the published
  * component was derived from — the schema module is now the only statement of the shape.
  */
-export type BrowserUseProjectConfiguration = z.infer<typeof BrowserUseProjectConfigurationSchema>;
+export type BrowserUseProjectConfiguration = Wire.BrowserUseProjectConfiguration;
 
 // ==========================================
 // Project Configuration
 // ==========================================
 
-export type ProjectSearchTier = z.infer<typeof ProjectSearchTierSchema>;
-export type ElasticsearchBackend = z.infer<typeof ElasticsearchBackendSchema>;
+export type ProjectSearchTier = Wire.ProjectSearchTier;
+export type ElasticsearchBackend = Wire.ElasticsearchBackend;
 
-export type ProjectIntakeSniffConfiguration = z.infer<typeof ProjectIntakeSniffConfigurationSchema>;
+export type ProjectIntakeSniffConfiguration = Wire.ProjectIntakeSniffConfiguration;
 
-export type ProjectIntakeConfiguration = z.infer<typeof ProjectIntakeConfigurationSchema>;
+export type ProjectIntakeConfiguration = Wire.ProjectIntakeConfiguration;
 
-export type ProjectConfiguration = z.infer<typeof ProjectConfigurationSchema>;
+export type ProjectConfiguration = Wire.ProjectConfiguration;
 
-export type AgentProjectConfiguration = z.infer<typeof AgentProjectConfigurationSchema>;
+export type AgentProjectConfiguration = Wire.AgentProjectConfiguration;
 
-export type AgentCheckpointConfiguration = z.infer<typeof AgentCheckpointConfigurationSchema>;
+export type AgentCheckpointConfiguration = Wire.AgentCheckpointConfiguration;
 
-export type ProjectSearchPropertyType = z.infer<typeof ProjectSearchPropertyTypeSchema>;
+export type AgentBudgetConfiguration = Wire.AgentBudgetConfiguration;
 
-export type ProjectSearchPropertyMapping = z.infer<typeof ProjectSearchPropertyMappingSchema>;
+export type ProjectSearchPropertyType = Wire.ProjectSearchPropertyType;
 
-export type ProjectIndexingConfiguration = z.infer<typeof ProjectIndexingConfigurationSchema>;
+export type ProjectSearchPropertyMapping = Wire.ProjectSearchPropertyMapping;
+
+export type ProjectIndexingConfiguration = Wire.ProjectIndexingConfiguration;
 
 // export interface ProjectConfigurationEmbeddings {
 //     environment: string;
@@ -201,30 +158,28 @@ export const SearchTypes = {
     ...FullTextType,
 } as const;
 
-export type ProjectConfigurationEmbedding = z.infer<typeof ProjectConfigurationEmbeddingSchema>;
+export type ProjectConfigurationEmbedding = Wire.ProjectConfigurationEmbedding;
 
-export type ProjectConfigurationEmbeddingEnablePayload = z.infer<
-    typeof ProjectConfigurationEmbeddingEnablePayloadSchema
->;
+export type ProjectConfigurationEmbeddingEnablePayload = Wire.ProjectConfigurationEmbeddingEnablePayload;
 
-export type Project = z.infer<typeof ProjectSchema>;
+export type Project = Wire.Project;
 
-export type ProjectPluginsUpdatePayload = z.infer<typeof ProjectPluginsUpdatePayloadSchema>;
+export type ProjectPluginsUpdatePayload = Wire.ProjectPluginsUpdatePayload;
 
 export const ProjectRefPopulate = 'id name account';
 
-export type EmbeddingsStatusResponse = z.infer<typeof EmbeddingsStatusResponseSchema>;
+export type EmbeddingsStatusResponse = Wire.EmbeddingsStatusResponse;
 
 /**
  * Response from indexing status endpoint
  */
-export type IndexingStatusResponse = z.infer<typeof IndexingStatusResponseSchema>;
+export type IndexingStatusResponse = Wire.IndexingStatusResponse;
 
-export type StartProjectReindexPayload = z.infer<typeof StartProjectReindexPayloadSchema>;
+export type StartProjectReindexPayload = Wire.StartProjectReindexPayload;
 
-export type ReindexAgentRunsPayload = z.infer<typeof ReindexAgentRunsPayloadSchema>;
+export type ReindexAgentRunsPayload = Wire.ReindexAgentRunsPayload;
 
-export type ReindexAgentRunsResponse = z.infer<typeof ReindexAgentRunsResponseSchema>;
+export type ReindexAgentRunsResponse = Wire.ReindexAgentRunsResponse;
 
 // ============================================================================
 // Internal indexing types (used by Temporal workflows)
@@ -424,6 +379,8 @@ export interface SwapAliasRequest {
     backend?: ElasticsearchBackend;
     /** ES alias name. If not provided, the Go service derives it from the tenant ID. */
     alias?: string;
+    /** Delete superseded versioned indices after the target has been validated. */
+    cleanup?: boolean;
 }
 
 export interface SwapAliasResult {
@@ -625,18 +582,18 @@ export interface AnalyzeDriftBatchResult {
     sample_stale_ids: string[];
 }
 
-export type DriftAnalysisProgress = z.infer<typeof DriftAnalysisProgressSchema>;
+export type DriftAnalysisProgress = Wire.DriftAnalysisProgress;
 
-export type DriftAnalysisResult = z.infer<typeof DriftAnalysisResultSchema>;
+export type DriftAnalysisResult = Wire.DriftAnalysisResult;
 
-export type DriftAnalysisStatusResponse = z.infer<typeof DriftAnalysisStatusResponseSchema>;
+export type DriftAnalysisStatusResponse = Wire.DriftAnalysisStatusResponse;
 
-export type ProjectIntegrationListEntry = z.infer<typeof ProjectIntegrationListEntrySchema>;
+export type ProjectIntegrationListEntry = Wire.ProjectIntegrationListEntry;
 
-export type ProjectIntegrationListResponse = z.infer<typeof ProjectIntegrationListResponseSchema>;
+export type ProjectIntegrationListResponse = Wire.ProjectIntegrationListResponse;
 
-export type UpdateProjectPayload = z.infer<typeof UpdateProjectPayloadSchema>;
+export type UpdateProjectPayload = Wire.UpdateProjectPayload;
 
-export type UpdateProjectConfigurationPayload = z.infer<typeof UpdateProjectConfigurationPayloadSchema>;
+export type UpdateProjectConfigurationPayload = Wire.UpdateProjectConfigurationPayload;
 
-export type IntakeVisionProfileSettingsUpdate = z.infer<typeof IntakeVisionProfileSettingsUpdateSchema>;
+export type IntakeVisionProfileSettingsUpdate = Wire.IntakeVisionProfileSettingsUpdate;

package/src/prompt.ts

@@ -1,22 +1,5 @@
 import type { JSONSchema, PromptRole } from '@llumiverse/common';
-import type { z } from 'zod';
-import type {
-    ExportedPromptTemplateRefSchema,
-    InteractionPromptSegmentInputSchema,
-    InteractionPromptTemplateInputSchema,
-    PromptTemplateCreatePayloadSchema,
-    PromptTemplateRefSchema,
-    PromptTemplateSchema,
-    PromptTemplateUpdatePayloadSchema,
-} from './api-schemas/interaction.js';
-import type {
-    PromptTemplateForkPayloadSchema,
-    PromptTemplateInteractionsResponseSchema,
-    PromptTemplateInteractionUsageSchema,
-    PromptTemplateInteractionVersionSchema,
-    RenderPromptPayloadSchema,
-    RenderPromptResponseSchema,
-} from './api-schemas/prompt.js';
+import type * as Wire from './wire-types.generated.js';
 
 export interface ChatPromptSchema {
     role: PromptRole.user | PromptRole.assistant;
@@ -51,7 +34,7 @@ export interface ExecutablePromptSegmentDef extends Omit<PromptSegmentDef, 'temp
     template?: ExecutablePromptTemplate;
 }
 
-export type PromptTemplateRef = z.infer<typeof PromptTemplateRefSchema>;
+export type PromptTemplateRef = Wire.PromptTemplateRef;
 
 export enum TemplateType {
     jst = 'jst',
@@ -64,25 +47,25 @@ export interface ExecutablePromptTemplate {
     content_type: TemplateType;
     inputSchema?: JSONSchema;
 }
-export type PromptTemplate = z.infer<typeof PromptTemplateSchema>;
+export type PromptTemplate = Wire.PromptTemplate;
 
-export type InteractionPromptTemplateInput = z.infer<typeof InteractionPromptTemplateInputSchema>;
+export type InteractionPromptTemplateInput = Wire.InteractionPromptTemplateInput;
 
-export type InteractionPromptSegmentInput = z.infer<typeof InteractionPromptSegmentInputSchema>;
+export type InteractionPromptSegmentInput = Wire.InteractionPromptSegmentInput;
 
-export type PromptTemplateForkPayload = z.infer<typeof PromptTemplateForkPayloadSchema>;
+export type PromptTemplateForkPayload = Wire.PromptTemplateForkPayload;
 
-export type PromptTemplateCreatePayload = z.infer<typeof PromptTemplateCreatePayloadSchema>;
+export type PromptTemplateCreatePayload = Wire.PromptTemplateCreatePayload;
 
-export type PromptTemplateUpdatePayload = z.infer<typeof PromptTemplateUpdatePayloadSchema>;
+export type PromptTemplateUpdatePayload = Wire.PromptTemplateUpdatePayload;
 
-export type PromptTemplateInteractionVersion = z.infer<typeof PromptTemplateInteractionVersionSchema>;
+export type PromptTemplateInteractionVersion = Wire.PromptTemplateInteractionVersion;
 
-export type PromptTemplateInteractionUsage = z.infer<typeof PromptTemplateInteractionUsageSchema>;
+export type PromptTemplateInteractionUsage = Wire.PromptTemplateInteractionUsage;
 
-export type PromptTemplateInteractionsResponse = z.infer<typeof PromptTemplateInteractionsResponseSchema>;
+export type PromptTemplateInteractionsResponse = Wire.PromptTemplateInteractionsResponse;
 
-export type RenderPromptPayload = z.infer<typeof RenderPromptPayloadSchema>;
+export type RenderPromptPayload = Wire.RenderPromptPayload;
 
 /**
  * What `POST /prompts/:id/render` answers with: the segment identity plus the rendered body.
@@ -90,6 +73,6 @@ export type RenderPromptPayload = z.infer<typeof RenderPromptPayloadSchema>;
  * Stated here for the first time — the endpoint declared its response inline, so there has never
  * been a name for it on either side of the wire.
  */
-export type RenderPromptResponse = z.infer<typeof RenderPromptResponseSchema>;
+export type RenderPromptResponse = Wire.RenderPromptResponse;
 
-export type ExportedPromptTemplateRef = z.infer<typeof ExportedPromptTemplateRefSchema>;
+export type ExportedPromptTemplateRef = Wire.ExportedPromptTemplateRef;