@vertesia/common 1.5.0-dev.20260725.083715Z → 1.5.0-dev.20260806.125520Z

package/src/store/process.ts

@@ -1,57 +1,66 @@
+import type { z } from 'zod';
+import type {
+    BranchDefinitionSchema,
+    BranchJoinPolicySchema,
+    HumanTaskDefinitionSchema,
+    JsonLogicRuleSchema,
+    ListProcessDefinitionsQuerySchema,
+    NodeHistoryEntrySchema,
+    ParallelCollectDefinitionSchema,
+    ParallelCollectFieldSchema,
+    ParallelCollectModeSchema,
+    ParallelFailurePolicySchema,
+    ProcessContextDefinitionSchema,
+    ProcessDefinitionFormatVersionSchema,
+    ProcessDefinitionMetadataSchema,
+    ProcessDefinitionRevisionInfoSchema,
+    ProcessDefinitionStatusSchema,
+    ProcessHistoryRefSchema,
+    ProcessNodeReturnsDefinitionSchema,
+    ProcessNodeRunTypeSchema,
+    ProcessNodeTypeSchema,
+    ProcessResourcesDefinitionSchema,
+    ProcessScriptInlineSourceSchema,
+    ProcessScriptLanguageSchema,
+    ProcessScriptResourceSchema,
+    ProcessScriptSourceSchema,
+    ProcessStateSchema,
+    PublishProcessDefinitionPayloadSchema,
+    RevertProcessDefinitionPayloadSchema,
+    TransitionDefinitionSchema,
+    TransitionTriggerSchema,
+} from '../api-schemas/process.js';
 import type { JSONSchema } from '../json-schema.js';
-import type { TaskField } from './task.js';
 
-export type JsonLogicRule = Record<string, unknown>;
+export type JsonLogicRule = z.infer<typeof JsonLogicRuleSchema>;
 
-export type ProcessDefinitionStatus = 'draft' | 'published' | 'archived';
+export type ProcessDefinitionStatus = z.infer<typeof ProcessDefinitionStatusSchema>;
+export type ListProcessDefinitionsQuery = z.infer<typeof ListProcessDefinitionsQuerySchema>;
 export const PROCESS_DEFINITION_FORMAT_VERSION = 1 as const;
-export type ProcessDefinitionFormatVersion = typeof PROCESS_DEFINITION_FORMAT_VERSION;
+export type ProcessDefinitionFormatVersion = z.infer<typeof ProcessDefinitionFormatVersionSchema>;
 
-export type ProcessNodeType =
-    | 'tool'
-    | 'interaction'
-    | 'agent'
-    | 'process'
-    | 'human_task'
-    | 'foreach'
-    | 'branch'
-    | 'condition'
-    | 'final';
+export type ProcessNodeType = z.infer<typeof ProcessNodeTypeSchema>;
 
-export type TransitionTrigger = 'auto' | 'agent' | 'user';
-export type ParallelFailurePolicy = 'fail_fast' | 'collect_errors';
-export type ProcessNodeRunType = 'supervised' | 'programmatic';
-export type ParallelCollectMode = 'array';
-export type BranchJoinPolicy = 'all';
-export type ProcessDefinitionMetadata = Record<string, unknown>;
-export type ParallelCollectField =
-    | 'status'
-    | 'index'
-    | 'item'
-    | 'item_id'
-    | 'branch_id'
-    | 'branch_title'
-    | 'output'
-    | 'context_update'
-    | 'error'
-    | 'child_run_id'
-    | 'child_workflow_id'
-    | 'child_workflow_run_id';
+export type TransitionTrigger = z.infer<typeof TransitionTriggerSchema>;
+export type ParallelFailurePolicy = z.infer<typeof ParallelFailurePolicySchema>;
+export type ProcessNodeRunType = z.infer<typeof ProcessNodeRunTypeSchema>;
+export type ParallelCollectMode = z.infer<typeof ParallelCollectModeSchema>;
+export type BranchJoinPolicy = z.infer<typeof BranchJoinPolicySchema>;
+export type ProcessDefinitionMetadata = z.infer<typeof ProcessDefinitionMetadataSchema>;
+export type ProcessScriptLanguage = z.infer<typeof ProcessScriptLanguageSchema>;
 
-export interface TransitionDefinition {
-    to: string;
-    guard?: JsonLogicRule;
-    trigger?: TransitionTrigger;
-    label?: string;
-    metadata?: ProcessDefinitionMetadata;
-}
+export type ProcessScriptInlineSource = z.infer<typeof ProcessScriptInlineSourceSchema>;
 
-export interface BranchDefinition {
-    to: string;
-    when?: JsonLogicRule;
-    default?: boolean;
-    metadata?: ProcessDefinitionMetadata;
-}
+export type ProcessScriptSource = z.infer<typeof ProcessScriptSourceSchema>;
+
+export type ProcessScriptResource = z.infer<typeof ProcessScriptResourceSchema>;
+
+export type ProcessResourcesDefinition = z.infer<typeof ProcessResourcesDefinitionSchema>;
+export type ParallelCollectField = z.infer<typeof ParallelCollectFieldSchema>;
+
+export type TransitionDefinition = z.infer<typeof TransitionDefinitionSchema>;
+
+export type BranchDefinition = z.infer<typeof BranchDefinitionSchema>;
 
 export interface BranchNodeBranchDefinition {
     id: string;
@@ -61,49 +70,19 @@ export interface BranchNodeBranchDefinition {
     metadata?: ProcessDefinitionMetadata;
 }
 
-export interface HumanTaskDefinition {
-    title: string;
-    description?: string;
-    /**
-     * Who owns the task. Either a group reference (`group:<name>`) or a
-     * concrete user id. Leave unset to make the task available to anyone
-     * who can see the inbox. `role:<name>` is not supported — use
-     * `group:<name>` instead.
-     */
-    assignee?: string;
-    fields: TaskField[];
-}
+export type HumanTaskDefinition = z.infer<typeof HumanTaskDefinitionSchema>;
 
-export interface ProcessNodeReturnsDefinition {
-    /**
-     * Path to read from the completed child process state. Use `context.foo`
-     * for child context values or `state.sequence` for process-state fields.
-     * If omitted, the child context is used as the node output.
-     */
-    from?: string;
-    /**
-     * Select specific fields from the completed child process context.
-     * Ignored when `from` is set.
-     */
-    context?: string[];
-}
+export type ProcessNodeReturnsDefinition = z.infer<typeof ProcessNodeReturnsDefinitionSchema>;
 
-export interface ParallelCollectDefinition {
-    /**
-     * Context key that receives the collected results.
-     */
-    into: string;
-    mode?: ParallelCollectMode;
-    /**
-     * Fields to include in each collected item. Defaults to the operational
-     * envelope: status, index, item_id, output, error, and child_run_id.
-     */
-    include?: ParallelCollectField[];
-}
+export type ParallelCollectDefinition = z.infer<typeof ParallelCollectDefinitionSchema>;
 
 export interface NodeDefinition {
     type: ProcessNodeType;
     tool?: string;
+    /** Named entry in process resources.scripts for script nodes. */
+    script?: string;
+    /** Script execution timeout in seconds. Defaults to 300 and is capped at 600. */
+    timeout?: number;
     interaction?: string;
     process?: string;
     process_definition?: ProcessDefinitionBody;
@@ -154,10 +133,7 @@ export interface NodeDefinition {
     metadata?: ProcessDefinitionMetadata;
 }
 
-export interface ProcessContextDefinition {
-    schema: JSONSchema;
-    initial: Record<string, unknown>;
-}
+export type ProcessContextDefinition = z.infer<typeof ProcessContextDefinitionSchema>;
 
 export interface ProcessDefinitionBody {
     format_version: ProcessDefinitionFormatVersion;
@@ -165,6 +141,7 @@ export interface ProcessDefinitionBody {
     description?: string;
     initial: string;
     model?: string;
+    resources?: ProcessResourcesDefinition;
     context: ProcessContextDefinition;
     nodes: Record<string, NodeDefinition>;
     metadata?: ProcessDefinitionMetadata;
@@ -184,18 +161,7 @@ export interface InCodeProcessDefinition {
     definition: ProcessDefinitionBody;
 }
 
-export interface ProcessDefinitionRevisionInfo {
-    /** Direct parent revision id. Omitted for the first revision in a bucket. */
-    parent?: string;
-    /** Root revision id shared by all revisions of the same process definition. */
-    root: string;
-    /** True when this is the latest revision returned by default list/resolve calls. */
-    head: boolean;
-    /** Optional human-readable label for the revision. */
-    label?: string;
-    /** Optional publish note captured when a draft is promoted. */
-    comment?: string;
-}
+export type ProcessDefinitionRevisionInfo = z.infer<typeof ProcessDefinitionRevisionInfoSchema>;
 
 export interface ProcessDefinition {
     id: string;
@@ -214,26 +180,9 @@ export interface ProcessDefinition {
     updated_by: string;
 }
 
-export interface NodeHistoryEntry {
-    id?: string;
-    node: string;
-    attempt?: number;
-    entered_at: Date | string;
-    exited_at?: Date | string;
-    status: 'running' | 'completed' | 'skipped' | 'failed' | 'cancelled';
-    context_diff?: Record<string, unknown>;
-    data_ref?: string;
-    sequence?: number;
-    child_run_id?: string;
-    child_workflow_id?: string;
-    child_workflow_run_id?: string;
-}
+export type NodeHistoryEntry = z.infer<typeof NodeHistoryEntrySchema>;
 
-export interface ProcessHistoryRef {
-    path: string;
-    latest_sequence: number;
-    count: number;
-}
+export type ProcessHistoryRef = z.infer<typeof ProcessHistoryRefSchema>;
 
 export interface ProcessHistoryCheckpoint {
     sequence: number;
@@ -242,18 +191,7 @@ export interface ProcessHistoryCheckpoint {
     entries: NodeHistoryEntry[];
 }
 
-export interface ProcessState {
-    context: Record<string, unknown>;
-    current_node: string;
-    node_history: NodeHistoryEntry[];
-    node_history_ref?: ProcessHistoryRef;
-    sequence: number;
-    _current_node?: string;
-    _previous_node?: string;
-    _transition_count?: number;
-    _node_entries?: Record<string, number>;
-    _node_tool_calls?: Record<string, number>;
-}
+export type ProcessState = z.infer<typeof ProcessStateSchema>;
 
 export interface CreateProcessDefinitionPayload {
     name: string;
@@ -286,20 +224,6 @@ export interface UpdateProcessDefinitionPayload {
     definition?: ProcessDefinitionBody;
 }
 
-export interface PublishProcessDefinitionPayload {
-    /** Required explicit confirmation from the caller. */
-    confirmed: boolean;
-    /** Optional tags to merge into the published revision. */
-    tags?: string[];
-    /** Optional human-readable revision label. */
-    label?: string;
-    /** Optional publish note. */
-    comment?: string;
-}
+export type PublishProcessDefinitionPayload = z.infer<typeof PublishProcessDefinitionPayloadSchema>;
 
-export interface RevertProcessDefinitionPayload {
-    /** Required explicit confirmation from the caller. */
-    confirmed: boolean;
-    /** Optional note explaining why this version is being restored as the draft. */
-    comment?: string;
-}
+export type RevertProcessDefinitionPayload = z.infer<typeof RevertProcessDefinitionPayloadSchema>;

package/src/store/rendering.ts

@@ -4,8 +4,16 @@
  * Types for rendering content to various formats (PDF, DOCX, images)
  */
 
+import type { z } from 'zod';
+import type {
+    PdfRenderingMetadataSchema,
+    RenderMarkdownPayloadSchema,
+    RenderMarkdownStartResponseSchema,
+    RenderMarkdownStatusQuerySchema,
+    RenderMarkdownStatusResponseSchema,
+} from '../api-schemas/document-processing.js';
 import type { ImageRenditionFormat, MarkdownRenditionFormat } from './store.js';
-import { WorkflowExecutionStatus, type WorkflowRunStatus } from './workflow.js';
+import { WorkflowExecutionStatus } from './workflow.js';
 
 // ============================================================================
 // Workflow Vars Types (Discriminated Union)
@@ -35,21 +43,8 @@ export function getRenditionsPath(contentEtag: string, params: ImageRenditionPar
     return `renditions/${contentEtag}/${params.max_hw}`;
 }
 
-/** Metadata for PDF rendering (displayed in header/footer) */
-export interface PdfRenderingMetadata {
-    /** Document ID to display in footer */
-    document_id?: string;
-    /** Agent name that generated the document */
-    agent_name?: string;
-    /** Agent run ID to display in footer */
-    agent_run_id?: string;
-    /** Document subtitle */
-    subtitle?: string;
-    /** Document author(s) */
-    author?: string | string[];
-    /** Document date (displayed in header and title page; defaults to today if omitted) */
-    date?: string;
-}
+/** Metadata for PDF rendering, inferred from the published API schema. */
+export type PdfRenderingMetadata = z.infer<typeof PdfRenderingMetadataSchema>;
 
 /** Workflow vars for markdown renditions (pdf, docx) */
 export interface MarkdownRenditionVars extends BaseRenditionVars {
@@ -96,64 +91,20 @@ export function isMarkdownRenditionVars(vars: GenerateRenditionVars): vars is Ma
  * Payload for rendering markdown to PDF or DOCX.
  * Either object_id OR content must be provided.
  */
-export interface RenderMarkdownPayload {
-    /** Output format */
-    format: MarkdownRenditionFormat;
-    /** Object ID to render (mutually exclusive with content) */
-    object_id?: string;
-    /** Inline markdown content to render (mutually exclusive with object_id) */
-    content?: string;
-    /** Document title (used for filename when using inline content) */
-    title?: string;
-    /** URL to a template file for pandoc (DOCX reference doc or LaTeX template) */
-    template_url?: string;
-    /** Optional logo URL for template variable `logo-path` (studio-hosted URL) */
-    template_logo_url?: string;
-    /** Template file via artifact:/store: protocol (takes precedence over template_url) */
-    template_path?: string;
-    /** Logo file via artifact:/store: protocol (takes precedence over template_logo_url) */
-    logo_path?: string;
-    /** Use Vertesia default template if no template_url provided (default: true for pdf) */
-    use_default_template?: boolean;
-    /** Additional pandoc command-line options */
-    pandoc_options?: string[];
-    /** Run ID for resolving artifact: and image: URLs */
-    artifact_run_id?: string;
-    /** Document metadata for PDF footer/header */
-    metadata?: PdfRenderingMetadata;
-    /** Source reference for auto-wired template data: `store:<objectId>` or `artifact:<path-to-json>` */
-    template_data_source?: string;
-    /** Custom upload path for the rendered output */
-    output_path?: string;
-}
+export type RenderMarkdownPayload = z.infer<typeof RenderMarkdownPayloadSchema>;
 
 /**
  * Initial response when starting a markdown rendering workflow.
  * Clients should poll status using workflow_id/workflow_run_id.
  */
-export interface RenderMarkdownStartResponse extends WorkflowRunStatus {
-    /** Requested output format */
-    format: MarkdownRenditionFormat;
-}
+export type RenderMarkdownStartResponse = z.infer<typeof RenderMarkdownStartResponseSchema>;
 
 /**
  * Polled status response for markdown rendering workflow.
  */
-export interface RenderMarkdownStatusResponse extends WorkflowRunStatus {
-    /** Requested output format (if known) */
-    format?: MarkdownRenditionFormat;
-    /** Download URL for completed output */
-    download_url?: string;
-    /** File URI in storage for completed output */
-    file_uri?: string;
-    /** Error details for failed/terminated runs */
-    error?: string;
-}
+export type RenderMarkdownStatusResponse = z.infer<typeof RenderMarkdownStatusResponseSchema>;
 
-export interface RenderMarkdownStatusQuery {
-    workflow_id: string;
-    workflow_run_id: string;
-}
+export type RenderMarkdownStatusQuery = z.infer<typeof RenderMarkdownStatusQuerySchema>;
 
 /**
  * Client-side polling options for markdown rendering.