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

package/src/store/workflow.ts

@@ -1,44 +1,8 @@
 import type { HttpTimeoutOptions, ModelOptions } from '@llumiverse/common';
-import type { z } from 'zod';
-import type {
-    AgentMessageDetailsSchema,
-    CompactMessageSchema,
-    ConversationFileSchema,
-} from '../api-schemas/agent-runs.js';
-import type { ConversationActivityStateSchema } from '../api-schemas/app-lifecycle.js';
-import type { WorkflowExecutionStatusSchema } from '../api-schemas/document-processing.js';
-import type { PlanSchema, PlanTaskSchema, WorkflowAncestorSchema } from '../api-schemas/interaction.js';
-import type { WorkflowExecutionStartResultSchema } from '../api-schemas/process.js';
-import type {
-    ActivityTaskSchema,
-    AgentTaskSchema,
-    ChildWorkflowTaskSchema,
-    EventErrorSchema,
-    ExecuteWorkflowPayloadSchema,
-    ListWorkflowInteractionsResponseSchema,
-    ListWorkflowRunsPayloadSchema,
-    ListWorkflowRunsResponseSchema,
-    PendingActivitySchema,
-    SignalEventPropertiesSchema,
-    SignalTaskSchema,
-    TimerTaskSchema,
-    WorkflowActionResponseSchema,
-    WorkflowHistorySchema,
-    WorkflowInteractionVarsSchema,
-    WorkflowQueryResultSchema,
-    WorkflowRunDetailsQuerySchema,
-    WorkflowRunEventSchema,
-    WorkflowRunSchema,
-    WorkflowRunStreamQuerySchema,
-    WorkflowRunUpdatesQuerySchema,
-    WorkflowRunUpdatesResponseSchema,
-    WorkflowRunWithDetailsSchema,
-    WorkflowTaskSchema,
-    WorkflowUpdatePublishResponseSchema,
-} from '../api-schemas/workflow-runs.js';
 import type { AgentResourceReference, InteractionExecutionConfiguration } from '../interaction.js';
 import { normalizeAgentResources } from '../interaction.js';
 import type { SupportedEmbeddingTypes } from '../project.js';
+import type * as Wire from '../wire-types.generated.js';
 import type { WorkflowInput } from './dsl-workflow.js';
 
 export enum ContentEventName {
@@ -59,7 +23,7 @@ export interface Queue {
     queue_full_name?: string; // full name
 }
 
-export type WorkflowAncestor = z.infer<typeof WorkflowAncestorSchema>;
+export type WorkflowAncestor = Wire.WorkflowAncestor;
 
 export interface WorkflowExecutionBaseParams<T = Record<string, unknown>> {
     /** Effective principal for private scheduled runs; server supplied. */
@@ -208,17 +172,17 @@ export function getDocumentIds(payload: WorkflowExecutionPayload<Record<string,
     return [];
 }
 
-export type ExecuteWorkflowPayload = z.infer<typeof ExecuteWorkflowPayloadSchema>;
+export type ExecuteWorkflowPayload = Wire.ExecuteWorkflowPayload;
 
-export type ConversationActivityState = z.infer<typeof ConversationActivityStateSchema>;
+export type ConversationActivityState = Wire.ConversationActivityState;
 
-export type ListWorkflowRunsPayload = z.infer<typeof ListWorkflowRunsPayloadSchema>;
+export type ListWorkflowRunsPayload = Wire.ListWorkflowRunsPayload;
 
-export type SignalEventProperties = z.infer<typeof SignalEventPropertiesSchema>;
+export type SignalEventProperties = Wire.SignalEventProperties;
 
-export type EventError = z.infer<typeof EventErrorSchema>;
+export type EventError = Wire.EventError;
 
-export type WorkflowRunEvent = z.infer<typeof WorkflowRunEventSchema>;
+export type WorkflowRunEvent = Wire.WorkflowRunEvent;
 
 // Task status enum for processed history
 export enum TaskStatus {
@@ -242,51 +206,51 @@ export enum TaskType {
 }
 
 // Activity-specific task
-export type ActivityTask = z.infer<typeof ActivityTaskSchema>;
+export type ActivityTask = Wire.ActivityTask;
 
 // Child workflow-specific task
-export type ChildWorkflowTask = z.infer<typeof ChildWorkflowTaskSchema>;
+export type ChildWorkflowTask = Wire.ChildWorkflowTask;
 
 // Signal-specific task
-export type SignalTask = z.infer<typeof SignalTaskSchema>;
+export type SignalTask = Wire.SignalTask;
 
 // Timer-specific task
-export type TimerTask = z.infer<typeof TimerTaskSchema>;
+export type TimerTask = Wire.TimerTask;
 
 // Union type for all processed tasks
-export type WorkflowTask = z.infer<typeof WorkflowTaskSchema>;
+export type WorkflowTask = Wire.WorkflowTask;
 
 // History format discriminated union
-export type WorkflowHistory = z.infer<typeof WorkflowHistorySchema>;
+export type WorkflowHistory = Wire.WorkflowHistory;
 
-export type AgentTask = z.infer<typeof AgentTaskSchema>;
+export type AgentTask = Wire.AgentTask;
 
-export type WorkflowRun = z.infer<typeof WorkflowRunSchema>;
+export type WorkflowRun = Wire.WorkflowRun;
 
-export type PendingActivity = z.infer<typeof PendingActivitySchema>;
+export type PendingActivity = Wire.PendingActivity;
 
-export type WorkflowRunWithDetails = z.infer<typeof WorkflowRunWithDetailsSchema>;
-export type ListWorkflowRunsResponse = z.infer<typeof ListWorkflowRunsResponseSchema>;
+export type WorkflowRunWithDetails = Wire.WorkflowRunWithDetails;
+export type ListWorkflowRunsResponse = Wire.ListWorkflowRunsResponse;
 
-export type WorkflowExecutionStartResult = z.infer<typeof WorkflowExecutionStartResultSchema>;
+export type WorkflowExecutionStartResult = Wire.WorkflowExecutionStartResult;
 
-export type ListWorkflowInteractionsResponse = z.infer<typeof ListWorkflowInteractionsResponseSchema>;
+export type ListWorkflowInteractionsResponse = Wire.ListWorkflowInteractionsResponse;
 
-export type WorkflowRunUpdatesResponse = z.infer<typeof WorkflowRunUpdatesResponseSchema>;
+export type WorkflowRunUpdatesResponse = Wire.WorkflowRunUpdatesResponse;
 
-export type WorkflowRunDetailsQuery = z.infer<typeof WorkflowRunDetailsQuerySchema>;
+export type WorkflowRunDetailsQuery = Wire.WorkflowRunDetailsQuery;
 
-export type WorkflowRunUpdatesQuery = z.infer<typeof WorkflowRunUpdatesQuerySchema>;
+export type WorkflowRunUpdatesQuery = Wire.WorkflowRunUpdatesQuery;
 
-export type WorkflowRunStreamQuery = z.infer<typeof WorkflowRunStreamQuerySchema>;
+export type WorkflowRunStreamQuery = Wire.WorkflowRunStreamQuery;
 
-export type WorkflowUpdatePublishResponse = z.infer<typeof WorkflowUpdatePublishResponseSchema>;
+export type WorkflowUpdatePublishResponse = Wire.WorkflowUpdatePublishResponse;
 
-export type WorkflowActionResponse = z.infer<typeof WorkflowActionResponseSchema>;
+export type WorkflowActionResponse = Wire.WorkflowActionResponse;
 
-export type WorkflowQueryResult = z.infer<typeof WorkflowQueryResultSchema>;
+export type WorkflowQueryResult = Wire.WorkflowQueryResult;
 
-export type WorkflowInteractionVars = z.infer<typeof WorkflowInteractionVarsSchema>;
+export type WorkflowInteractionVars = Wire.WorkflowInteractionVars;
 
 export const WorkflowExecutionStatusValues = {
     UNKNOWN: 0,
@@ -313,7 +277,7 @@ export const WorkflowExecutionStatus: typeof WorkflowExecutionStatusValues & Rea
     7: 'TIMED_OUT',
 };
 
-export type WorkflowExecutionStatus = z.infer<typeof WorkflowExecutionStatusSchema>;
+export type WorkflowExecutionStatus = Wire.WorkflowExecutionStatus;
 
 /**
  * Basic response for anything run with an async workflow
@@ -354,7 +318,7 @@ export enum AgentMessageType {
     RESTARTING = 14,
 }
 
-export type AgentMessageDetails = z.infer<typeof AgentMessageDetailsSchema>;
+export type AgentMessageDetails = Wire.AgentMessageDetails;
 
 // ============================================
 // AGENT MESSAGE DETAIL TYPES & TYPE GUARDS
@@ -421,7 +385,7 @@ export interface StreamingChunkDetails {
  * Primary type used throughout the system.
  * ~85% smaller than legacy AgentMessage format.
  */
-export type CompactMessage = z.infer<typeof CompactMessageSchema>;
+export type CompactMessage = Wire.CompactMessage;
 
 /**
  * Legacy message format for backward compatibility.
@@ -652,7 +616,7 @@ export enum FileProcessingStatus {
     ERROR = 'error',
 }
 
-export type ConversationFile = z.infer<typeof ConversationFileSchema>;
+export type ConversationFile = Wire.ConversationFile;
 
 /**
  * Details for file processing SYSTEM messages.
@@ -721,9 +685,9 @@ export interface ConversationFileRemovedRef {
     id: string;
 }
 
-export type PlanTask = z.infer<typeof PlanTaskSchema>;
+export type PlanTask = Wire.PlanTask;
 
-export type Plan = z.infer<typeof PlanSchema>;
+export type Plan = Wire.Plan;
 
 export const LOW_PRIORITY_TASK_QUEUE = 'low_priority';
 

package/src/sts-token-types.ts

@@ -1,36 +1,17 @@
-/**
- * STS Token Request Types
- * These types define the structure for token requests to the Security Token Service
- */
-import type { z } from 'zod';
-import type {
-    AgentTokenRequestSchema,
-    ApiKeyTokenRequestSchema,
-    AppSessionTokenRequestSchema,
-    AppSessionTokenResponseSchema,
-    EnvironmentTokenRequestSchema,
-    IssueTokenForbiddenResponseSchema,
-    IssueTokenRequestSchema,
-    IssueTokenResponseSchema,
-    IssueTokenUnavailableResponseSchema,
-    ProjectTokenRequestSchema,
-    ServiceAccountTokenRequestSchema,
-    SigningAlgorithmSchema,
-    UserTokenRequestSchema,
-} from './api-schemas/sts.js';
-export type SigningAlgorithm = z.infer<typeof SigningAlgorithmSchema>;
+import type * as Wire from './wire-types.generated.js';
+export type SigningAlgorithm = Wire.SigningAlgorithm;
 
 // API key doesn't need account/project as it's determined from the key
-export type ApiKeyTokenRequest = z.infer<typeof ApiKeyTokenRequestSchema>;
+export type ApiKeyTokenRequest = Wire.ApiKeyTokenRequest;
 
 // User token needs optional account/project for scoping
-export type UserTokenRequest = z.infer<typeof UserTokenRequestSchema>;
+export type UserTokenRequest = Wire.UserTokenRequest;
 
 // Project token requires project_id and account_id
-export type ProjectTokenRequest = z.infer<typeof ProjectTokenRequestSchema>;
+export type ProjectTokenRequest = Wire.ProjectTokenRequest;
 
 // Environment token requires IDs - names fetched from DB
-export type EnvironmentTokenRequest = z.infer<typeof EnvironmentTokenRequestSchema>;
+export type EnvironmentTokenRequest = Wire.EnvironmentTokenRequest;
 
 /**
  * Agent token for a service account to act as agent on behalf of a user.
@@ -41,15 +22,15 @@ export type EnvironmentTokenRequest = z.infer<typeof EnvironmentTokenRequestSche
  * - `workload_id_token`: a workload acts on behalf of a user. It implies that a full verification
  *   will be performed based on the workload identity.
  */
-export type AgentTokenRequest = z.infer<typeof AgentTokenRequestSchema>;
+export type AgentTokenRequest = Wire.AgentTokenRequest;
 
 // Service account token
-export type ServiceAccountTokenRequest = z.infer<typeof ServiceAccountTokenRequestSchema>;
+export type ServiceAccountTokenRequest = Wire.ServiceAccountTokenRequest;
 
 /**
  * @discriminator type
  */
-export type IssueTokenRequest = z.infer<typeof IssueTokenRequestSchema>;
+export type IssueTokenRequest = Wire.IssueTokenRequest;
 
 export interface RefreshTokenRequest {
     token: string;
@@ -66,8 +47,8 @@ export interface TokenResponse {
     expires_in?: number;
 }
 
-export type IssueTokenResponse = z.infer<typeof IssueTokenResponseSchema>;
-export type IssueTokenForbiddenResponse = z.infer<typeof IssueTokenForbiddenResponseSchema>;
+export type IssueTokenResponse = Wire.IssueTokenResponse;
+export type IssueTokenForbiddenResponse = Wire.IssueTokenForbiddenResponse;
 
 export interface ValidateTokenResponse {
     valid: boolean;
@@ -75,7 +56,7 @@ export interface ValidateTokenResponse {
     error?: string;
 }
 
-export type IssueTokenUnavailableResponse = z.infer<typeof IssueTokenUnavailableResponseSchema>;
+export type IssueTokenUnavailableResponse = Wire.IssueTokenUnavailableResponse;
 
-export type AppSessionTokenRequest = z.infer<typeof AppSessionTokenRequestSchema>;
-export type AppSessionTokenResponse = z.infer<typeof AppSessionTokenResponseSchema>;
+export type AppSessionTokenRequest = Wire.AppSessionTokenRequest;
+export type AppSessionTokenResponse = Wire.AppSessionTokenResponse;

package/src/tools.ts

@@ -1,39 +1,26 @@
-import type { z } from 'zod';
-import type {
-    AggregatedToolSchema,
-    InspectProjectToolQuerySchema,
-    ListProjectToolsQuerySchema,
-    ProcessToolCompatibilityReasonSchema,
-    ProcessToolCompatibilitySchema,
-    ToolInspectionSchema,
-    ToolRuntimeContextSchema,
-    ToolSourceSchema,
-    ToolValidationResultSchema,
-    ValidateToolNamesPayloadSchema,
-    ValidateToolNamesResponseSchema,
-} from './api-schemas/tools.js';
+import type * as Wire from './wire-types.generated.js';
 
 // The unified project-scoped tool registry, inferred from `./api-schemas/tools.js`. The
 // documentation for each member lives on the schema, which is what the OpenAPI document publishes.
 
-export type ToolSource = z.infer<typeof ToolSourceSchema>;
+export type ToolSource = Wire.ToolSource;
 
-export type AggregatedTool = z.infer<typeof AggregatedToolSchema>;
+export type AggregatedTool = Wire.AggregatedTool;
 
-export type ToolRuntimeContext = z.infer<typeof ToolRuntimeContextSchema>;
+export type ToolRuntimeContext = Wire.ToolRuntimeContext;
 
-export type ProcessToolCompatibilityReason = z.infer<typeof ProcessToolCompatibilityReasonSchema>;
+export type ProcessToolCompatibilityReason = Wire.ProcessToolCompatibilityReason;
 
-export type ProcessToolCompatibility = z.infer<typeof ProcessToolCompatibilitySchema>;
+export type ProcessToolCompatibility = Wire.ProcessToolCompatibility;
 
-export type InspectProjectToolQuery = z.infer<typeof InspectProjectToolQuerySchema>;
+export type InspectProjectToolQuery = Wire.InspectProjectToolQuery;
 
-export type ToolInspection = z.infer<typeof ToolInspectionSchema>;
+export type ToolInspection = Wire.ToolInspection;
 
-export type ListProjectToolsQuery = z.infer<typeof ListProjectToolsQuerySchema>;
+export type ListProjectToolsQuery = Wire.ListProjectToolsQuery;
 
-export type ToolValidationResult = z.infer<typeof ToolValidationResultSchema>;
+export type ToolValidationResult = Wire.ToolValidationResult;
 
-export type ValidateToolNamesPayload = z.infer<typeof ValidateToolNamesPayloadSchema>;
+export type ValidateToolNamesPayload = Wire.ValidateToolNamesPayload;
 
-export type ValidateToolNamesResponse = z.infer<typeof ValidateToolNamesResponseSchema>;
+export type ValidateToolNamesResponse = Wire.ValidateToolNamesResponse;

package/src/transient-tokens.ts

@@ -1,6 +1,6 @@
-import type { z } from 'zod';
-import type { UserInviteTokenDataSchema, UserInviteTokenFromSchema } from './api-schemas/invites.js';
+import type { UserInviteTokenFromSchema } from './api-schemas/invites.js';
 import type { TransientTokenType } from './transient-tokens-values.js';
+import type * as Wire from './wire-types.generated.js';
 
 /**
  * `TransientTokenType` lives in `./transient-tokens-values.js` so the API schemas can read it
@@ -22,7 +22,7 @@ export interface TransientToken<T> {
  * The invite payload as it crosses the wire, inferred from `./api-schemas/invites.js`. Every
  * reference is populated by the handlers before the response is built.
  */
-export type UserInviteTokenData = z.infer<typeof UserInviteTokenDataSchema>;
+export type UserInviteTokenData = Wire.UserInviteTokenData;
 
 /** One pending invite, as the three invite listings publish it. */
 export type UserInviteToken = UserInviteTokenFromSchema;

package/src/user.ts

@@ -1,26 +1,4 @@
-import type { z } from 'zod';
-import type {
-    AccountApiVersionPolicySchema,
-    AccountBillingSchema,
-    AccountSchema,
-    UpdateAccountPayloadSchema,
-} from './api-schemas/account.js';
-import type {
-    AccountProjectsResponseSchema,
-    AccountRefSchema,
-    InviteAcceptanceResponseSchema,
-    InviteDeclineResponseSchema,
-    InviteUserRequestPayloadSchema,
-    InviteUserResponsePayloadSchema,
-    OnboardingProgressSchema,
-} from './api-schemas/invites.js';
-import type {
-    SignupDataSchema,
-    SignupPayloadSchema,
-    UpdateUserPayloadSchema,
-    UserRefSchema,
-    UserSchema,
-} from './api-schemas/user.js';
+import type * as Wire from './wire-types.generated.js';
 
 export * from './account-values.js';
 
@@ -34,8 +12,8 @@ export * from './account-values.js';
  * `@dglabs/server-common` describes what Mongo actually holds (optional email, ObjectId
  * references, Date timestamps) and is deliberately independent of this type.
  */
-export type User = z.infer<typeof UserSchema>;
-export type UpdateUserPayload = z.infer<typeof UpdateUserPayloadSchema>;
+export type User = Wire.User;
+export type UpdateUserPayload = Wire.UpdateUserPayload;
 
 /**
  * The compact user shape embedded in other resources' responses, derived from `UserRefSchema`.
@@ -43,7 +21,7 @@ export type UpdateUserPayload = z.infer<typeof UpdateUserPayloadSchema>;
  * `UserRefPopulate` is the Mongoose projection that produces it, and the two are meant to stay in
  * step: a field added here without adding it there yields a response missing the field.
  */
-export type UserRef = z.infer<typeof UserRefSchema>;
+export type UserRef = Wire.UserRef;
 
 export const UserRefPopulate = 'id name email picture';
 
@@ -70,15 +48,15 @@ export { RESTRICTED_ENVIRONMENT_ERROR_CODE } from './sts-errors.js';
  * bundle — runtime consumers reach the schemas through the `@vertesia/common/api-schemas` entry
  * point instead.
  */
-export type Account = z.infer<typeof AccountSchema>;
-export type AccountBilling = z.infer<typeof AccountBillingSchema>;
-export type UpdateAccountPayload = z.infer<typeof UpdateAccountPayloadSchema>;
+export type Account = Wire.Account;
+export type AccountBilling = Wire.AccountBilling;
+export type UpdateAccountPayload = Wire.UpdateAccountPayload;
 
 // The compact account reference, derived from the schema in `./api-schemas/invites.js`. It was
 // hand-written for the same reason `ProjectRef` was — `ExecutionRun` and `UserInviteTokenData` still
 // reach it through types the scanner derives — and is an alias now for the same reason: the scanner
 // short-circuits such an alias to the published component rather than failing to expand it.
-export type AccountRef = z.infer<typeof AccountRefSchema>;
+export type AccountRef = Wire.AccountRef;
 
 export const AccountRefPopulate = 'id name';
 
@@ -92,22 +70,20 @@ export const AccountRefPopulate = 'id name';
  * reads it and the alias is safe. `AccountRefSchema` is still the runtime source of truth, and the
  * `Equals` assertion in `invites.contract.test.ts` is what holds the interface to it.
  */
-export type InviteUserRequestPayload = z.infer<typeof InviteUserRequestPayloadSchema>;
-export type InviteUserResponsePayload = z.infer<typeof InviteUserResponsePayloadSchema>;
-export type InviteAcceptanceResponse = z.infer<typeof InviteAcceptanceResponseSchema>;
-export type InviteDeclineResponse = z.infer<typeof InviteDeclineResponseSchema>;
-export type AccountProjectsResponse = z.infer<typeof AccountProjectsResponseSchema>;
+export type InviteUserRequestPayload = Wire.InviteUserRequestPayload;
+export type InviteUserResponsePayload = Wire.InviteUserResponsePayload;
+export type InviteAcceptanceResponse = Wire.InviteAcceptanceResponse;
+export type InviteDeclineResponse = Wire.InviteDeclineResponse;
+export type AccountProjectsResponse = Wire.AccountProjectsResponse;
 
-export type OnboardingProgress = z.infer<typeof OnboardingProgressSchema>;
+export type OnboardingProgress = Wire.OnboardingProgress;
 
 /**
  * Data collected at signup, used for onboarding and segments.
  */
-export type SignupData = z.infer<typeof SignupDataSchema>;
+export type SignupData = Wire.SignupData;
 
 /**
  * The `POST /auth/signup` request body.
  */
-export type SignupPayload = z.infer<typeof SignupPayloadSchema>;
-
-export type AccountApiVersionPolicy = z.infer<typeof AccountApiVersionPolicySchema>;
+export type SignupPayload = Wire.SignupPayload;