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

package/src/api-contract/types.ts

@@ -0,0 +1,108 @@
+import type {
+    CreateEventSubscriptionPayload,
+    EventDeliveryTarget,
+    EventDeliveryTargetInput,
+    EventSubscription,
+    EventSubscriptionMutationResponse,
+    ProcessEventDeliveryTarget,
+    UpdateEventSubscriptionPayload,
+} from '../platform-event.js';
+import type {
+    AgentRunInternals,
+    AgentRunResponse,
+    BindRunWorkflowPayload,
+    ListAgentRunsResponse,
+    ProgrammaticRunResponse,
+    RecordRunPayload,
+    SupervisedRunResponse,
+    UpdateAgentRunStatusPayload,
+} from '../store/agent-run.js';
+import type * as DSLWorkflowTypes from '../store/dsl-workflow.js';
+import type {
+    DSLChildWorkflowStep,
+    DSLWorkflowDefinition,
+    DSLWorkflowDefinitionResponse,
+    DSLWorkflowSpec,
+    DSLWorkflowSpecWithSteps,
+    DSLWorkflowStep,
+} from '../store/dsl-workflow.js';
+import type {
+    BranchNodeBranchDefinition,
+    CreateProcessDefinitionPayload,
+    NodeDefinition,
+    ProcessDefinition,
+    ProcessDefinitionBody,
+    UpdateProcessDefinitionPayload,
+} from '../store/process.js';
+import type { ViewNavigationNode } from '../views.js';
+import type { ApiComponentTypes } from '../wire-types.generated.js';
+
+export type ApiComponentName = keyof ApiComponentTypes;
+
+/**
+ * Explicit TypeScript recursion boundary for schemas whose runtime graph is lazy.
+ *
+ * Zod cannot infer a finite named type through a mutually-recursive graph. The schemas remain the
+ * runtime and OpenAPI authority; these names preserve the recursive TypeScript declarations until
+ * TypeScript can infer recursive aliases without collapsing them to `unknown`.
+ */
+interface ZenoRecursiveComponentTypes {
+    ViewNavigationNode: ViewNavigationNode;
+    AgentRunResponse: AgentRunResponse;
+    AgentRunInternals: AgentRunInternals;
+    BindRunWorkflowPayload: BindRunWorkflowPayload;
+    BranchNodeBranchDefinition: BranchNodeBranchDefinition;
+    CreateEventSubscriptionPayload: CreateEventSubscriptionPayload;
+    CreateProcessDefinitionPayload: CreateProcessDefinitionPayload;
+    DSLChildWorkflowStep: DSLChildWorkflowStep;
+    DSLWorkflowDefinition: DSLWorkflowDefinition;
+    DSLWorkflowDefinitionResponse: DSLWorkflowDefinitionResponse;
+    DSLWorkflowSpec: DSLWorkflowSpec;
+    DSLWorkflowSpecWithActivities: DSLWorkflowTypes.DSLWorkflowSpecWithActivities;
+    DSLWorkflowSpecWithSteps: DSLWorkflowSpecWithSteps;
+    DSLWorkflowStep: DSLWorkflowStep;
+    EventDeliveryTarget: EventDeliveryTarget;
+    EventDeliveryTargetInput: EventDeliveryTargetInput;
+    EventSubscription: EventSubscription;
+    EventSubscriptionArray: EventSubscription[];
+    EventSubscriptionMutationResponse: EventSubscriptionMutationResponse;
+    ListAgentRunsResponse: ListAgentRunsResponse;
+    NodeDefinition: NodeDefinition;
+    NodeDefinitionMap: Record<string, NodeDefinition>;
+    ProcessDefinition: ProcessDefinition;
+    ProcessDefinitionArray: ProcessDefinition[];
+    ProcessDefinitionBody: ProcessDefinitionBody;
+    ProcessEventDeliveryTarget: ProcessEventDeliveryTarget;
+    ProgrammaticRunResponse: ProgrammaticRunResponse;
+    RecordRunPayload: RecordRunPayload;
+    SupervisedRunResponse: SupervisedRunResponse;
+    UpdateAgentRunStatusPayload: UpdateAgentRunStatusPayload;
+    UpdateEventSubscriptionPayload: UpdateEventSubscriptionPayload;
+    UpdateProcessDefinitionPayload: UpdateProcessDefinitionPayload;
+    WorkflowDefinitionPayload: DSLWorkflowTypes.WorkflowDefinitionPayload;
+    WorkflowDefinitionPayloadWithActivities: DSLWorkflowTypes.WorkflowDefinitionPayloadWithActivities;
+    WorkflowDefinitionPayloadWithSteps: DSLWorkflowTypes.WorkflowDefinitionPayloadWithSteps;
+}
+
+/**
+ * The wire type a component publishes.
+ *
+ * `ApiComponentType<'Account'>` is the plain type `gen:schemas` writes for `AccountSchema` into
+ * `ApiComponentTypes`, which `wire-types.generated.test.ts` proves identical to its `z.infer`. Indexing
+ * that map rather than `z.infer<ApiSchemaMap[N]>` keeps Zod's inference out of every program that names
+ * a component. A component the generator has not seen yet resolves to `never`, which
+ * `registry-groups.test.ts` rejects.
+ *
+ * It is wrapped in `NoInfer` because `N` always comes from a component-name argument and can never be
+ * recovered from the wire type. Without it, a call whose result has a contextual type — a destructuring
+ * `const { file } = validatedQuery(ctx, 'FileMetadataQuery')`, an `await`, a typed `return` — makes the
+ * checker infer `N` from that context while `N` is still unresolved, which evaluates `z.infer` across
+ * every component in the registry: about 500k types, 1 GB and 2 s of `tsc` in each consuming program.
+ */
+export type ApiComponentType<N extends ApiComponentName> = NoInfer<
+    N extends keyof ZenoRecursiveComponentTypes
+        ? ZenoRecursiveComponentTypes[N]
+        : N extends keyof ApiComponentTypes
+          ? ApiComponentTypes[N]
+          : never
+>;

package/src/api-schemas/account.ts

@@ -2,7 +2,6 @@ import { z } from 'zod';
 // From the values module, never from `user.ts`: `user.ts` derives its public types from the schemas
 // below, so importing it here would invert the dependency and make the source of truth circular.
 import { ACCOUNT_APP_ACCESS_MESSAGE_MAX_LENGTH, AccountType, BillingMethod, QuotaTier } from '../account-values.js';
-import { ApiVersions } from '../versions.js';
 import type * as Wire from '../wire-types.generated.js';
 
 /**
@@ -146,10 +145,3 @@ export type AccountBillingFromSchema = Wire.AccountBillingFromSchema;
 export type AccountFromSchema = Wire.AccountFromSchema;
 export type UpdateAccountPayloadFromSchema = Wire.UpdateAccountPayloadFromSchema;
 export type StripeBillingStatusResponseFromSchema = Wire.StripeBillingStatusResponseFromSchema;
-
-/** Account-wide defaults for request API version negotiation. */
-export const AccountApiVersionPolicySchema = z
-    .strictObject({
-        default_api_version: z.enum(ApiVersions).optional(),
-    })
-    .meta({ id: 'AccountApiVersionPolicy' });

package/src/api-schemas/audit-trail.ts

@@ -41,6 +41,10 @@ export const AuditAggregationDimensionMapSchema = z
         project_id: z.string().nullable().optional(),
         principal_id: z.string().nullable().optional(),
         actor_id: z.string().nullable().optional(),
+        user_id: z.string().nullable().optional().meta({
+            description:
+                'Originating user identity, including delegated and scheduled activity with a recorded user owner. Non-user principals without a user origin are excluded.',
+        }),
         'details.pipeline': z.string().nullable().optional(),
         'details.verdict': z.string().nullable().optional(),
         'details.workflow_type': z.string().nullable().optional(),
@@ -50,7 +54,7 @@ export const AuditAggregationDimensionMapSchema = z
     .meta({ id: 'AuditAggregationDimensionMap' });
 
 export const AuditAggregationDistinctFieldSchema = z
-    .enum(['resource_id', 'request_id', 'principal_id', 'actor_id'])
+    .enum(['resource_id', 'request_id', 'principal_id', 'actor_id', 'user_id'])
     .meta({ id: 'AuditAggregationDistinctField' });
 
 export const AuditAggregationOperationSchema = z
@@ -247,3 +251,167 @@ export const AuditTrailQuerySchema = z
         offset: z.number().meta({ description: 'Pagination: offset' }).optional(),
     })
     .meta({ id: 'AuditTrailQuery' });
+
+export const AuditAdoptionFilterSchema = z
+    .strictObject({
+        actions: z.array(AuditActionSchema).max(32).optional(),
+        resourceTypes: z.array(z.string().max(128)).max(16).optional(),
+        eventCategories: z.array(EventCategorySchema).max(6).optional(),
+    })
+    .meta({ id: 'AuditAdoptionFilter' });
+
+export const AuditAdoptionQuerySchema = z
+    .strictObject({
+        projectId: z.string().optional(),
+        from: z
+            .string()
+            .meta({ format: 'date-time', description: 'Inclusive start; defaults to 30 days before to.' })
+            .optional(),
+        to: z
+            .string()
+            .meta({ format: 'date-time', description: 'Exclusive end; defaults to now. Maximum duration: 366 days.' })
+            .optional(),
+        filter: AuditAdoptionFilterSchema.optional(),
+    })
+    .meta({
+        id: 'AuditAdoptionQuery',
+        description:
+            'Productive direct authenticated user activity, including user OAuth/MCP calls. Scope is enforced by the server.',
+    });
+
+export const AuditAdoptionPeriodSchema = z
+    .strictObject({
+        from: z.string().meta({ format: 'date-time' }),
+        to: z.string().meta({ format: 'date-time' }),
+    })
+    .meta({ id: 'AuditAdoptionPeriod' });
+
+export const AuditAdoptionBucketSchema = z
+    .strictObject({
+        from: z.string().meta({ format: 'date-time' }),
+        to: z.string().meta({ format: 'date-time' }),
+        partial: z.boolean(),
+        active_users: z.number().int().nonnegative(),
+    })
+    .meta({ id: 'AuditAdoptionBucket' });
+
+export const AuditAdoptionActiveDaysSchema = z
+    .strictObject({
+        days: z.number().int().min(1).max(367),
+        users: z.number().int().nonnegative(),
+    })
+    .meta({ id: 'AuditAdoptionActiveDays' });
+
+export const AuditAdoptionProjectSchema = z
+    .strictObject({
+        project_id: z.string(),
+        project_name: z.string().nullable(),
+        active_users: z.number().int().nonnegative(),
+        active_user_days: z.number().int().nonnegative(),
+    })
+    .meta({ id: 'AuditAdoptionProject' });
+
+export const AuditAdoptionHistorySchema = z
+    .strictObject({
+        earliest_observed_at: z.string().meta({ format: 'date-time' }).nullable(),
+        coverage_from: z
+            .string()
+            .meta({
+                format: 'date-time',
+                description:
+                    'Authoritative complete-history boundary, if known. Earliest observation is not a coverage boundary.',
+            })
+            .nullable(),
+        completeness: z.enum(['unknown', 'insufficient', 'verified']),
+        retention_unavailable_reason: z.enum(['no_previous_users', 'insufficient_history']).nullable(),
+    })
+    .meta({ id: 'AuditAdoptionHistory' });
+
+export const AuditAdoptionResponseSchema = z
+    .strictObject({
+        period: AuditAdoptionPeriodSchema,
+        previous_period: AuditAdoptionPeriodSchema,
+        resolution: z.enum(['day', 'week']),
+        active_users: z.number().int().nonnegative(),
+        previous_active_users: z.number().int().nonnegative(),
+        retained_users: z.number().int().nonnegative(),
+        observed_retention: z.number().min(0).max(1).nullable(),
+        returning_user_share: z.number().min(0).max(1).nullable(),
+        repeat_user_share: z.number().min(0).max(1).nullable(),
+        median_active_days: z.number().nonnegative().nullable(),
+        active_projects: z.number().int().nonnegative().nullable(),
+        timeline: z.array(AuditAdoptionBucketSchema),
+        active_day_distribution: z.array(AuditAdoptionActiveDaysSchema),
+        top_projects: z.array(AuditAdoptionProjectSchema).max(10),
+        history: AuditAdoptionHistorySchema,
+    })
+    .meta({
+        id: 'AuditAdoptionResponse',
+        description:
+            'Distinct user adoption sets over two equal-duration half-open periods. Ratios use available audit history, not guaranteed historical coverage. No user identities are returned.',
+    });
+
+export const AuditUsageQuerySchema = AuditAdoptionQuerySchema.omit({ filter: true })
+    .extend({
+        resolution: z.enum(['day', 'week', 'month']).optional().meta({
+            description: 'UTC calendar buckets. Weeks start Monday. Omitted: daily up to 200 dates, otherwise weekly.',
+        }),
+    })
+    .meta({
+        id: 'AuditUsageQuery',
+        description: 'Usage trends for an authorized account or project over a half-open interval of at most 366 days.',
+    });
+
+export const AuditUsageCountsSchema = z
+    .strictObject({
+        active_users: z.number().int().nonnegative(),
+        agent_runs: z
+            .number()
+            .int()
+            .nonnegative()
+            .meta({ description: 'All audited run creations and marked restarts, including automated runs.' }),
+        user_agent_runs: z
+            .number()
+            .int()
+            .nonnegative()
+            .meta({ description: 'Run operations initiated directly by authenticated users, including OAuth/MCP.' }),
+        automated_agent_runs: z.number().int().nonnegative().meta({
+            description: 'Other run operations, including schedules, delegated agents, services and API keys.',
+        }),
+        agent_users: z.number().int().nonnegative().meta({
+            description:
+                'Distinct identifiable user initiators or owners of run operations, including scheduled and delegated runs.',
+        }),
+        direct_calls: z.number().int().nonnegative(),
+        direct_call_users: z.number().int().nonnegative(),
+        content_objects: z.number().int().nonnegative(),
+        user_content_objects: z.number().int().nonnegative(),
+        other_content_objects: z.number().int().nonnegative(),
+    })
+    .meta({
+        id: 'AuditUsageCounts',
+        description:
+            'Direct productive users, run initiators/owners, all run operations and standalone inference audit events.',
+    });
+
+export const AuditUsageBucketSchema = z
+    .strictObject({
+        from: z.string().meta({ format: 'date-time' }),
+        to: z.string().meta({ format: 'date-time' }),
+        partial: z.boolean(),
+        counts: AuditUsageCountsSchema,
+    })
+    .meta({ id: 'AuditUsageBucket' });
+
+export const AuditUsageResponseSchema = z
+    .strictObject({
+        period: AuditAdoptionPeriodSchema,
+        resolution: z.enum(['day', 'week', 'month']),
+        totals: AuditUsageCountsSchema,
+        timeline: z.array(AuditUsageBucketSchema),
+    })
+    .meta({
+        id: 'AuditUsageResponse',
+        description:
+            'UTC usage trends. Period-wide distinct users are not sums of bucket populations. No user identities are returned.',
+    });

package/src/api-schemas/cost-analytics.ts

@@ -66,6 +66,14 @@ export const CostAnalyticsQuerySchema = z
         workflow_run_id: z.string().meta({ description: 'Filter by Temporal workflow run ID' }).optional(),
         run_id: z.string().meta({ description: 'Filter by interaction execution run ID' }).optional(),
         agent_run_id: z.string().meta({ description: 'Filter by agent run ID' }).optional(),
+        agent_only: z
+            .boolean()
+            .meta({
+                description:
+                    'Restrict usage to agent runs and their attributed nested/background inference. ' +
+                    'Excludes standalone interactions and non-agent workflows. Defaults to false.',
+            })
+            .optional(),
         interaction_id: z
             .string()
             .meta({ description: 'Filter by interaction id: stored ObjectId or namespaced in-code id' })

package/src/api-schemas/group.ts

@@ -55,6 +55,11 @@ export const UserGroupSchema = z
                     '(usable in any project). When set, the group may only be used to grant permissions in the ' +
                     'listed projects.',
             }),
+        member_count: z
+            .number()
+            .int()
+            .optional()
+            .meta({ description: 'Number of users in the group. Returned by the group listing only.' }),
     })
     .meta({ id: 'UserGroup' });
 

package/src/api-schemas/index.ts

@@ -16,6 +16,7 @@ export * from './agent-runs.js';
 export * from './analytics.js';
 export * from './apikey.js';
 export * from './app-runtime.js';
+export { EventCategorySchema } from './audit-trail.js';
 export * from './bulk-operation.js';
 export * from './content.js';
 export * from './content-query.js';

package/src/api-schemas/registry.ts

@@ -32,44 +32,10 @@ import {
     VideoResultSchema,
 } from '@llumiverse/common/schemas';
 import type { z } from 'zod';
-import type {
-    CreateEventSubscriptionPayload,
-    EventDeliveryTarget,
-    EventDeliveryTargetInput,
-    EventSubscription,
-    EventSubscriptionMutationResponse,
-    ProcessEventDeliveryTarget,
-    UpdateEventSubscriptionPayload,
-} from '../platform-event.js';
-import type {
-    AgentRunInternals,
-    AgentRunResponse,
-    BindRunWorkflowPayload,
-    ListAgentRunsResponse,
-    ProgrammaticRunResponse,
-    RecordRunPayload,
-    SupervisedRunResponse,
-    UpdateAgentRunStatusPayload,
-} from '../store/agent-run.js';
-import type * as DSLWorkflowTypes from '../store/dsl-workflow.js';
-import type {
-    DSLChildWorkflowStep,
-    DSLWorkflowDefinition,
-    DSLWorkflowDefinitionResponse,
-    DSLWorkflowSpec,
-    DSLWorkflowSpecWithSteps,
-    DSLWorkflowStep,
-} from '../store/dsl-workflow.js';
-import type {
-    BranchNodeBranchDefinition,
-    CreateProcessDefinitionPayload,
-    NodeDefinition,
-    ProcessDefinition,
-    ProcessDefinitionBody,
-    UpdateProcessDefinitionPayload,
-} from '../store/process.js';
-import type { ViewNavigationNode } from '../views.js';
-import type { ApiComponentTypes } from '../wire-types.generated.js';
+import type { ApiComponentType } from '../api-contract/types.js';
+
+export type { ApiComponentType } from '../api-contract/types.js';
+
 import {
     ACECreatePayloadSchema,
     ACEUpdatePayloadSchema,
@@ -78,12 +44,7 @@ import {
     RoleDefinitionArraySchema,
     SystemRoleDefinitionArraySchema,
 } from './access-control.js';
-import {
-    AccountApiVersionPolicySchema,
-    AccountSchema,
-    StripeBillingStatusResponseSchema,
-    UpdateAccountPayloadSchema,
-} from './account.js';
+import { AccountSchema, StripeBillingStatusResponseSchema, UpdateAccountPayloadSchema } from './account.js';
 import { type JsonObject, toOpenApiComponents } from './adapter.js';
 import * as AgentCommunicationSchemas from './agent-communication.js';
 import * as AgentRunSchemas from './agent-runs.js';
@@ -209,6 +170,14 @@ import {
 } from './apps.js';
 import {
     AuditActionSchema,
+    AuditAdoptionActiveDaysSchema,
+    AuditAdoptionBucketSchema,
+    AuditAdoptionFilterSchema,
+    AuditAdoptionHistorySchema,
+    AuditAdoptionPeriodSchema,
+    AuditAdoptionProjectSchema,
+    AuditAdoptionQuerySchema,
+    AuditAdoptionResponseSchema,
     AuditAggregationDetailFieldSchema,
     AuditAggregationDetailFilterSchema,
     AuditAggregationDimensionMapSchema,
@@ -226,6 +195,10 @@ import {
     AuditTrailEventSchema,
     AuditTrailQuerySchema,
     AuditTrailResponseSchema,
+    AuditUsageBucketSchema,
+    AuditUsageCountsSchema,
+    AuditUsageQuerySchema,
+    AuditUsageResponseSchema,
     EventCategorySchema,
     KnownAuditActionSchema,
 } from './audit-trail.js';
@@ -862,7 +835,6 @@ import * as WorkflowRunSchemas from './workflow-runs.js';
  * group approaches the proven-safe size.
  */
 const IAM_AND_ACCOUNT_SCHEMAS = {
-    AccountApiVersionPolicy: AccountApiVersionPolicySchema,
     Account: AccountSchema,
     UpdateAccountPayload: UpdateAccountPayloadSchema,
     StripeBillingStatusResponse: StripeBillingStatusResponseSchema,
@@ -2116,6 +2088,18 @@ const REMOTE_MCP_SCHEMAS = {
 } as const satisfies Record<string, z.ZodType>;
 
 const AUDIT_TRAIL_SCHEMAS = {
+    AuditAdoptionActiveDays: AuditAdoptionActiveDaysSchema,
+    AuditAdoptionBucket: AuditAdoptionBucketSchema,
+    AuditAdoptionFilter: AuditAdoptionFilterSchema,
+    AuditAdoptionHistory: AuditAdoptionHistorySchema,
+    AuditAdoptionPeriod: AuditAdoptionPeriodSchema,
+    AuditAdoptionProject: AuditAdoptionProjectSchema,
+    AuditAdoptionQuery: AuditAdoptionQuerySchema,
+    AuditAdoptionResponse: AuditAdoptionResponseSchema,
+    AuditUsageQuery: AuditUsageQuerySchema,
+    AuditUsageCounts: AuditUsageCountsSchema,
+    AuditUsageBucket: AuditUsageBucketSchema,
+    AuditUsageResponse: AuditUsageResponseSchema,
     // The audit trail: the events the endpoint pages through and the aggregation it
     // computes over them.
     AuditMeter: AuditMeterSchema,
@@ -2297,17 +2281,6 @@ const SECRET_SCHEMAS = {
     SecretProjectQuery: SecretSchemas.SecretProjectQuerySchema,
     ListSecretsQuery: SecretSchemas.ListSecretsQuerySchema,
     SecretLookupQuery: SecretSchemas.SecretLookupQuerySchema,
-    EventWebhookSigningSecretRequest: SecretSchemas.EventWebhookSigningSecretRequestSchema,
-    EventWebhookSigningSecretResponse: SecretSchemas.EventWebhookSigningSecretResponseSchema,
-    SignEventWebhookRequest: SecretSchemas.SignEventWebhookRequestSchema,
-    SignEventWebhookResponse: SecretSchemas.SignEventWebhookResponseSchema,
-    EventIngestSigningSecretRequest: SecretSchemas.EventIngestSigningSecretRequestSchema,
-    EventIngestSigningSecretResponse: SecretSchemas.EventIngestSigningSecretResponseSchema,
-    VerifyEventIngestSignatureRequest: SecretSchemas.VerifyEventIngestSignatureRequestSchema,
-    VerifyEventIngestSignatureResponse: SecretSchemas.VerifyEventIngestSignatureResponseSchema,
-    GithubInstallationTokenRequest: SecretSchemas.GithubInstallationTokenRequestSchema,
-    GithubInstallationTokenResponse: SecretSchemas.GithubInstallationTokenResponseSchema,
-    InternalSecretDeleteResponse: SecretSchemas.InternalSecretDeleteResponseSchema,
 } as const satisfies Record<string, z.ZodType>;
 
 const INTEGRATION_SCHEMAS = {
@@ -2441,10 +2414,6 @@ const DELEGATION_SCHEMAS = {
     DelegationGrantArray: DelegationGrantArraySchema,
 };
 const RUN_BUDGET_SCHEMAS = {
-    RunBudgetOwner: RunBudgetSchemas.RunBudgetOwnerSchema,
-    RunBudgetUsage: RunBudgetSchemas.RunBudgetUsageSchema,
-    ReadRunBudgetUsagePayload: RunBudgetSchemas.ReadRunBudgetUsagePayloadSchema,
-    RunBudgetTotals: RunBudgetSchemas.RunBudgetTotalsSchema,
     RunBudgetCapability: RunBudgetSchemas.RunBudgetCapabilitySchema,
     RunBudgetCapabilityQuery: RunBudgetSchemas.RunBudgetCapabilityQuerySchema,
 };
@@ -3418,6 +3387,18 @@ const STRICT_COMPONENTS: ReadonlySet<string> = new Set<string>([
     'AuditAggregationFilter',
     'AuditTrailResponse',
     'AuditAggregationQuery',
+    'AuditAdoptionActiveDays',
+    'AuditAdoptionBucket',
+    'AuditAdoptionFilter',
+    'AuditAdoptionHistory',
+    'AuditAdoptionPeriod',
+    'AuditAdoptionProject',
+    'AuditAdoptionQuery',
+    'AuditAdoptionResponse',
+    'AuditUsageQuery',
+    'AuditUsageCounts',
+    'AuditUsageBucket',
+    'AuditUsageResponse',
     'ViewSortClause',
     'ViewResultMedia',
     'ViewBoardColumn',
@@ -3584,17 +3565,6 @@ const STRICT_COMPONENTS: ReadonlySet<string> = new Set<string>([
     'ActivityCatalog',
     'WorkflowInteractionVars',
     'ListWorkflowInteractionsResponse',
-    'EventWebhookSigningSecretRequest',
-    'EventWebhookSigningSecretResponse',
-    'SignEventWebhookRequest',
-    'SignEventWebhookResponse',
-    'EventIngestSigningSecretRequest',
-    'EventIngestSigningSecretResponse',
-    'VerifyEventIngestSignatureRequest',
-    'VerifyEventIngestSignatureResponse',
-    'GithubInstallationTokenRequest',
-    'GithubInstallationTokenResponse',
-    'InternalSecretDeleteResponse',
 ]);
 
 /**
@@ -3647,74 +3617,6 @@ export function buildApiSchemaComponents(): Readonly<Record<string, JsonObject>>
     return toOpenApiComponents(emitRawSchemas(), { strictComponents: STRICT_COMPONENTS });
 }
 
-/**
- * Explicit TypeScript recursion boundary for schemas whose runtime graph is lazy.
- *
- * Zod cannot infer a finite named type through a mutually-recursive graph. The schemas remain the
- * runtime and OpenAPI authority; these names preserve the recursive TypeScript declarations until
- * TypeScript can infer recursive aliases without collapsing them to `unknown`.
- */
-interface ZenoRecursiveComponentTypes {
-    ViewNavigationNode: ViewNavigationNode;
-    AgentRunResponse: AgentRunResponse;
-    AgentRunInternals: AgentRunInternals;
-    BindRunWorkflowPayload: BindRunWorkflowPayload;
-    BranchNodeBranchDefinition: BranchNodeBranchDefinition;
-    CreateEventSubscriptionPayload: CreateEventSubscriptionPayload;
-    CreateProcessDefinitionPayload: CreateProcessDefinitionPayload;
-    DSLChildWorkflowStep: DSLChildWorkflowStep;
-    DSLWorkflowDefinition: DSLWorkflowDefinition;
-    DSLWorkflowDefinitionResponse: DSLWorkflowDefinitionResponse;
-    DSLWorkflowSpec: DSLWorkflowSpec;
-    DSLWorkflowSpecWithActivities: DSLWorkflowTypes.DSLWorkflowSpecWithActivities;
-    DSLWorkflowSpecWithSteps: DSLWorkflowSpecWithSteps;
-    DSLWorkflowStep: DSLWorkflowStep;
-    EventDeliveryTarget: EventDeliveryTarget;
-    EventDeliveryTargetInput: EventDeliveryTargetInput;
-    EventSubscription: EventSubscription;
-    EventSubscriptionArray: EventSubscription[];
-    EventSubscriptionMutationResponse: EventSubscriptionMutationResponse;
-    ListAgentRunsResponse: ListAgentRunsResponse;
-    NodeDefinition: NodeDefinition;
-    NodeDefinitionMap: Record<string, NodeDefinition>;
-    ProcessDefinition: ProcessDefinition;
-    ProcessDefinitionArray: ProcessDefinition[];
-    ProcessDefinitionBody: ProcessDefinitionBody;
-    ProcessEventDeliveryTarget: ProcessEventDeliveryTarget;
-    ProgrammaticRunResponse: ProgrammaticRunResponse;
-    RecordRunPayload: RecordRunPayload;
-    SupervisedRunResponse: SupervisedRunResponse;
-    UpdateAgentRunStatusPayload: UpdateAgentRunStatusPayload;
-    UpdateEventSubscriptionPayload: UpdateEventSubscriptionPayload;
-    UpdateProcessDefinitionPayload: UpdateProcessDefinitionPayload;
-    WorkflowDefinitionPayload: DSLWorkflowTypes.WorkflowDefinitionPayload;
-    WorkflowDefinitionPayloadWithActivities: DSLWorkflowTypes.WorkflowDefinitionPayloadWithActivities;
-    WorkflowDefinitionPayloadWithSteps: DSLWorkflowTypes.WorkflowDefinitionPayloadWithSteps;
-}
-
-/**
- * The wire type a component publishes.
- *
- * `ApiComponentType<'Account'>` is the plain type `gen:schemas` writes for `AccountSchema` into
- * `ApiComponentTypes`, which `wire-types.generated.test.ts` proves identical to its `z.infer`. Indexing
- * that map rather than `z.infer<ApiSchemaMap[N]>` keeps Zod's inference out of every program that names
- * a component. A component the generator has not seen yet resolves to `never`, which
- * `registry-groups.test.ts` rejects.
- *
- * It is wrapped in `NoInfer` because `N` always comes from a component-name argument and can never be
- * recovered from the wire type. Without it, a call whose result has a contextual type — a destructuring
- * `const { file } = validatedQuery(ctx, 'FileMetadataQuery')`, an `await`, a typed `return` — makes the
- * checker infer `N` from that context while `N` is still unresolved, which evaluates `z.infer` across
- * every component in the registry: about 500k types, 1 GB and 2 s of `tsc` in each consuming program.
- */
-export type ApiComponentType<N extends ApiComponentName> = NoInfer<
-    N extends keyof ZenoRecursiveComponentTypes
-        ? ZenoRecursiveComponentTypes[N]
-        : N extends keyof ApiComponentTypes
-          ? ApiComponentTypes[N]
-          : never
->;
-
 /**
  * Names a published component from inside a handler signature:
  * `Promise<ApiSchemaOf<'Account'>>`.

package/src/api-schemas/run-budget.ts

@@ -1,42 +1,5 @@
 import { z } from 'zod';
 
-export const RunBudgetOwnerSchema = z
-    .strictObject({
-        workflow_id: z.string().min(1),
-        first_run_id: z.string().min(1),
-    })
-    .meta({ id: 'RunBudgetOwner' });
-
-/** Cumulative counters are read from existing execution runs, never from an audit cursor. */
-export const RunBudgetUsageSchema = z
-    .strictObject({
-        input: z.number().nonnegative(),
-        cached_input: z.number().nonnegative(),
-        output: z.number().nonnegative(),
-    })
-    .meta({ id: 'RunBudgetUsage' });
-
-export const RunBudgetTotalsSchema = z
-    .strictObject({
-        measured: RunBudgetUsageSchema,
-        unpriced: RunBudgetUsageSchema,
-        reported_nano_usd: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-        estimated_nano_usd: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-        unmeasured_calls: z.number().int().nonnegative(),
-        missing_usage_calls: z.number().int().nonnegative(),
-    })
-    .meta({ id: 'RunBudgetTotals' });
-
-export const ReadRunBudgetUsagePayloadSchema = z
-    .strictObject({
-        account_id: z.string().min(1),
-        project_id: z.string().min(1),
-        agent_run_id: z.string().min(1),
-        owner: RunBudgetOwnerSchema,
-        require_estimates: z.boolean().optional(),
-    })
-    .meta({ id: 'ReadRunBudgetUsagePayload' });
-
 export const RunBudgetCapabilitySchema = z
     .strictObject({
         supported: z.boolean(),