skedyul 1.2.40 → 1.2.43

package/dist/compiler/types.d.ts

@@ -0,0 +1,173 @@
+import type { ResolvedSkill } from '../skills/types';
+/**
+ * Validation error from compilation
+ */
+export interface ValidationError {
+    path: string;
+    message: string;
+    severity: 'error' | 'warning';
+}
+/**
+ * Validation warning from compilation
+ */
+export interface ValidationWarning {
+    path: string;
+    message: string;
+}
+/**
+ * Resolved persona configuration
+ */
+export interface ResolvedPersona {
+    name: string;
+    style: string;
+    format?: {
+        maxChars?: number;
+        noEmojis?: boolean;
+        noHyphens?: boolean;
+        noBulletPoints?: boolean;
+        maxQuestionsPerMessage?: number;
+        noSignOffs?: boolean;
+    };
+}
+/**
+ * Resolved tool configuration
+ */
+export interface ResolvedTool {
+    id: string;
+    kind: 'SYSTEM' | 'AGENT' | 'MCP';
+    name: string;
+    server?: string;
+    approval?: {
+        required: boolean;
+        conditions?: string[];
+    };
+}
+/**
+ * Event configuration
+ */
+export interface EventConfig {
+    subscribes: string[];
+    emits: string[];
+    waits: Array<{
+        event: string;
+        timeout?: string;
+        onTimeout?: string;
+    }>;
+    cancels: string[];
+    condition?: string;
+    cancelCondition?: string;
+}
+/**
+ * Memory configuration for IR
+ */
+export interface IRMemoryConfig {
+    working?: {
+        strategy: 'full' | 'rolling_summary' | 'sliding_window';
+        maxTokens: number;
+        summarizeAt?: number;
+    };
+    persistent?: {
+        namespace?: string;
+    };
+    semantic?: {
+        enabled: boolean;
+        topK: number;
+        scope: 'thread' | 'instance' | 'workspace';
+    };
+}
+/**
+ * Policy configuration
+ */
+export interface PolicyConfig {
+    response?: {
+        requiresApproval: boolean;
+        conditions?: string[];
+    };
+    rules: string[];
+}
+/**
+ * Runtime configuration
+ */
+export interface IRRuntimeConfig {
+    model: string;
+    timeout: string;
+    retry?: {
+        attempts?: number;
+        backoff?: 'linear' | 'exponential';
+    };
+}
+/**
+ * Agent Intermediate Representation (IR)
+ * This is the compiled form of an agent YAML
+ */
+export interface AgentIR {
+    version: string;
+    handle: string;
+    name: string;
+    description?: string;
+    persona?: ResolvedPersona;
+    skills: ResolvedSkill[];
+    tools: ResolvedTool[];
+    events: EventConfig;
+    memory: IRMemoryConfig;
+    policies: PolicyConfig;
+    runtime: IRRuntimeConfig;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+    requiredPermissions: string[];
+    estimatedTokens: number;
+}
+/**
+ * Workflow step in IR
+ */
+export interface WorkflowStepIR {
+    id: string;
+    service: string;
+    cmd: string;
+    needs: string[];
+    inputs: Record<string, unknown>;
+    condition?: string;
+    timeout?: string;
+    retry?: {
+        attempts?: number;
+        backoff?: 'linear' | 'exponential';
+    };
+}
+/**
+ * Workflow Intermediate Representation (IR)
+ */
+export interface WorkflowIR {
+    version: string;
+    handle: string;
+    name: string;
+    description?: string;
+    inputs: Record<string, {
+        type: string;
+        required: boolean;
+        description?: string;
+        default?: unknown;
+    }>;
+    events: EventConfig;
+    steps: WorkflowStepIR[];
+    runtime: {
+        durable: boolean;
+        timeout?: string;
+        retry?: {
+            attempts?: number;
+            backoff?: 'linear' | 'exponential';
+        };
+    };
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+    stepOrder: string[];
+    hasCycles: boolean;
+}
+/**
+ * Compilation result
+ */
+export interface CompilationResult<T> {
+    success: boolean;
+    ir?: T;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+}

package/dist/config/index.d.ts

@@ -13,5 +13,6 @@ export type { InstallConfig, ProvisionConfig, BuildConfig, CorsOptions, SkedyulC
 export { defineConfig } from './app-config';
 export { defineModel, defineChannel, definePage, defineWorkflow, defineAgent, defineEnv, defineNavigation, } from './define';
 export { CONFIG_FILE_NAMES, loadConfig, validateConfig } from './loader';
+export { SCHEMA_FILE_EXTENSIONS, loadSchema, saveSchema, serializeSchemaToJson, serializeSchemaToTypeScript, transformToBackendSchema, transformFromBackendSchema, type LoadSchemaOptions, type LoadSchemaResult, type SerializeSchemaOptions, type BackendModelDefinition, type BackendFieldDefinition, type BackendRelationshipDefinition, type BackendDesiredSchema, } from './schema-loader';
 export { loadAndResolveConfig, serializeResolvedConfig, type ResolvedConfig } from './resolver';
 export { getAllEnvKeys, getRequiredInstallEnvKeys } from './utils';

package/dist/config/schema-loader.d.ts

@@ -0,0 +1,156 @@
+import { type CRMSchema } from '../schemas/crm-schema';
+export declare const SCHEMA_FILE_EXTENSIONS: string[];
+export interface LoadSchemaOptions {
+    /** Validate the schema after loading (default: true) */
+    validate?: boolean;
+}
+export interface LoadSchemaResult {
+    schema: CRMSchema;
+    filePath: string;
+    format: 'typescript' | 'json';
+}
+/**
+ * Load a CRM schema from a file.
+ * Supports both .schema.ts (TypeScript) and .schema.json (JSON) formats.
+ *
+ * @param schemaPath - Path to the schema file
+ * @param options - Loading options
+ * @returns The loaded and validated schema
+ * @throws Error if the file doesn't exist, can't be parsed, or fails validation
+ */
+export declare function loadSchema(schemaPath: string, options?: LoadSchemaOptions): Promise<LoadSchemaResult>;
+export interface SerializeSchemaOptions {
+    /** Include $schema field in JSON output (default: true) */
+    includeSchemaUrl?: boolean;
+    /** Pretty print JSON (default: true) */
+    pretty?: boolean;
+}
+/**
+ * Serialize a CRM schema to JSON string.
+ */
+export declare function serializeSchemaToJson(schema: CRMSchema, options?: SerializeSchemaOptions): string;
+/**
+ * Serialize a CRM schema to TypeScript string.
+ */
+export declare function serializeSchemaToTypeScript(schema: CRMSchema): string;
+/**
+ * Save a CRM schema to a file.
+ * Format is determined by file extension.
+ */
+export declare function saveSchema(schema: CRMSchema, outputPath: string, options?: SerializeSchemaOptions): Promise<void>;
+/**
+ * Backend-compatible model definition.
+ */
+export interface BackendModelDefinition {
+    handle: string;
+    name: string;
+    namePlural?: string;
+    labelTemplate: string;
+    description?: string;
+    icon?: string;
+    fields?: BackendFieldDefinition[];
+}
+/**
+ * Backend-compatible field definition.
+ */
+export interface BackendFieldDefinition {
+    handle: string;
+    label: string;
+    type: string;
+    helpText?: string | null;
+    isList?: boolean;
+    isUnique?: boolean;
+    requirement?: string;
+    defaultValue?: {
+        value: unknown[];
+    };
+    definition?: string | {
+        type: string;
+        options?: Array<{
+            value: string;
+            label: string;
+            color?: string | null;
+        }>;
+    };
+}
+/**
+ * Backend-compatible relationship definition.
+ */
+export interface BackendRelationshipDefinition {
+    source: {
+        model: string;
+        field: string;
+        label: string;
+    };
+    target: {
+        model: string;
+        field: string;
+        label: string;
+    };
+    cardinality: string;
+    onDelete?: string;
+}
+/**
+ * Backend-compatible block definition.
+ */
+export interface BackendBlockDefinition {
+    type: string;
+    title?: string;
+    config?: unknown;
+    default?: boolean;
+}
+/**
+ * Backend-compatible page definition.
+ */
+export interface BackendPageDefinition {
+    path: string;
+    type: string;
+    title: string;
+    icon?: string;
+    modelHandle: string;
+    parentPath?: string;
+    baseQuery?: unknown;
+    blocks?: BackendBlockDefinition[];
+}
+/**
+ * Backend-compatible navigation item definition.
+ */
+export interface BackendNavigationItemDefinition {
+    label: string;
+    icon?: string;
+    path: string;
+    sortIndex?: number;
+}
+/**
+ * Backend-compatible navigation definition.
+ */
+export interface BackendNavigationDefinition {
+    sidebar?: BackendNavigationItemDefinition[];
+}
+/**
+ * Backend-compatible desired schema format.
+ */
+export interface BackendDesiredSchema {
+    models: BackendModelDefinition[];
+    relationships: BackendRelationshipDefinition[];
+    fieldDefinitions: Array<{
+        handle: string;
+        type: string;
+        options?: Array<{
+            value: string;
+            label: string;
+            color?: string | null;
+        }>;
+    }>;
+    pages?: BackendPageDefinition[];
+    navigation?: BackendNavigationDefinition;
+}
+/**
+ * Transform a CRM schema to the backend's DesiredSchema format.
+ */
+export declare function transformToBackendSchema(schema: CRMSchema): BackendDesiredSchema;
+/**
+ * Transform a backend schema to CRM schema format.
+ * Used when pulling schema from a workplace.
+ */
+export declare function transformFromBackendSchema(backendSchema: BackendDesiredSchema, name: string, description?: string, version?: string): CRMSchema;

package/dist/config/types/model.d.ts

@@ -68,6 +68,32 @@ export interface FieldVisibility {
     /** Show in filter panels */
     filters?: boolean;
 }
+/**
+ * Field mutability - controls which operations can modify this field.
+ * Used to generate different tool schemas for different agent types.
+ * - 'always': Field can be set on create and updated anytime (default)
+ * - 'restricted': Field can be set on create, but updates require a dedicated tool
+ *                 (generates individual update tools like update_email, update_phone)
+ * - 'create_only': Field can only be set on create, excluded from all update tools
+ * - 'immutable': Field cannot be set by agents (system-managed)
+ */
+export type FieldMutability = 'always' | 'restricted' | 'create_only' | 'immutable';
+/**
+ * AI-specific metadata for fields.
+ * Controls how AI agents understand and interact with fields.
+ */
+export interface FieldAIMeta {
+    /** AI-specific description explaining how to populate this field */
+    description?: string;
+    /**
+     * Field mutability - controls which operations can modify this field.
+     * - 'always': Included in create and update tools (default)
+     * - 'restricted': Included in create, generates dedicated update tool
+     * - 'create_only': Included in create only, excluded from all update tools
+     * - 'immutable': Excluded from all agent tools (system-managed)
+     */
+    mutability?: FieldMutability;
+}
 /**
  * Field definition within a model.
  */
@@ -111,6 +137,8 @@ export interface FieldDefinition {
     visibility?: FieldVisibility;
     /** Who controls the field definition: 'app' or 'shared' */
     owner?: FieldOwner;
+    /** AI-specific metadata for agent interactions */
+    aiMeta?: FieldAIMeta;
 }
 /**
  * Model definition.

package/dist/context/index.d.ts

@@ -0,0 +1,2 @@
+export { CRMContextSchema, SenderContextSchema, ThreadContextItemSchema, ThreadInfoSchema, AgentContextSchema, MockSenderContextSchema, MockThreadContextSchema, MockContextSchema, SandboxConfigSchema, type CRMContext, type SenderContext, type ThreadContextItem, type ThreadInfo, type AgentContext, type MockSenderContext, type MockThreadContext, type MockContext, type SandboxConfig, } from './types';
+export { buildAgentContext, buildContextFromMock, formatContextForPrompt, getContextByHandle, getContextByModel, } from './resolver';

package/dist/context/resolver.d.ts

@@ -0,0 +1,51 @@
+import type { AgentContext, ThreadContextItem, MockContext } from './types';
+/**
+ * Build agent context from thread data
+ * This is a utility for building the context object that gets passed to agents
+ */
+export declare function buildAgentContext(params: {
+    thread: {
+        id: string;
+        title?: string;
+        status?: string;
+        kind?: string;
+    };
+    sender: {
+        kind: 'CONTACT' | 'MEMBER' | 'AGENT' | 'WORKFLOW';
+        displayName?: string;
+        email?: string;
+        role?: string;
+        permissions?: string[];
+        crm?: {
+            model: string;
+            instanceId: string;
+            data: Record<string, unknown>;
+        };
+    };
+    contexts?: Array<{
+        handle: string;
+        model: string;
+        instanceId: string;
+        data?: Record<string, unknown>;
+    }>;
+    workplace?: {
+        id: string;
+        name?: string;
+    };
+}): AgentContext;
+/**
+ * Build agent context from mock context (for sandbox testing)
+ */
+export declare function buildContextFromMock(mockContext: MockContext, threadId: string, workplaceId?: string): AgentContext;
+/**
+ * Format context for system prompt injection
+ */
+export declare function formatContextForPrompt(context: AgentContext): string;
+/**
+ * Get CRM data from context by model handle
+ */
+export declare function getContextByHandle(context: AgentContext, handle: string): ThreadContextItem | undefined;
+/**
+ * Get CRM data from context by model type
+ */
+export declare function getContextByModel(context: AgentContext, model: string): ThreadContextItem | undefined;

package/dist/context/types.d.ts

@@ -0,0 +1,217 @@
+import { z } from 'zod/v4';
+/**
+ * CRM context - data from a CRM instance
+ */
+export declare const CRMContextSchema: z.ZodObject<{
+    model: z.ZodString;
+    instanceId: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type CRMContext = z.infer<typeof CRMContextSchema>;
+/**
+ * Sender context - who sent the message
+ */
+export declare const SenderContextSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        CONTACT: "CONTACT";
+        MEMBER: "MEMBER";
+        AGENT: "AGENT";
+        WORKFLOW: "WORKFLOW";
+    }>;
+    displayName: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    crm: z.ZodOptional<z.ZodObject<{
+        model: z.ZodString;
+        instanceId: z.ZodString;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SenderContext = z.infer<typeof SenderContextSchema>;
+/**
+ * Thread context item - a linked CRM instance
+ */
+export declare const ThreadContextItemSchema: z.ZodObject<{
+    handle: z.ZodString;
+    model: z.ZodString;
+    instanceId: z.ZodString;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ThreadContextItem = z.infer<typeof ThreadContextItemSchema>;
+/**
+ * Thread info in context
+ */
+export declare const ThreadInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ThreadInfo = z.infer<typeof ThreadInfoSchema>;
+/**
+ * Full agent context - what the agent sees
+ */
+export declare const AgentContextSchema: z.ZodObject<{
+    sender: z.ZodObject<{
+        kind: z.ZodEnum<{
+            CONTACT: "CONTACT";
+            MEMBER: "MEMBER";
+            AGENT: "AGENT";
+            WORKFLOW: "WORKFLOW";
+        }>;
+        displayName: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
+        permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        crm: z.ZodOptional<z.ZodObject<{
+            model: z.ZodString;
+            instanceId: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    contexts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        handle: z.ZodString;
+        model: z.ZodString;
+        instanceId: z.ZodString;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    thread: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    workplace: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentContext = z.infer<typeof AgentContextSchema>;
+/**
+ * Mock context for sandbox testing
+ */
+/**
+ * Mock subscription - channel identifier for the contact
+ */
+export declare const MockSubscriptionSchema: z.ZodObject<{
+    identifierValue: z.ZodString;
+    channelHandle: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MockSubscription = z.infer<typeof MockSubscriptionSchema>;
+/**
+ * Mock association - CRM instance linked to a contact
+ */
+export declare const MockAssociationSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type MockAssociation = z.infer<typeof MockAssociationSchema>;
+/**
+ * Mock contact - mirrors production contact structure
+ */
+export declare const MockContactSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    subscription: z.ZodOptional<z.ZodObject<{
+        identifierValue: z.ZodString;
+        channelHandle: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    associations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type MockContact = z.infer<typeof MockContactSchema>;
+export declare const MockSenderContextSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        contact: "contact";
+        member: "member";
+    }>;
+    displayName: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    contact: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        subscription: z.ZodOptional<z.ZodObject<{
+            identifierValue: z.ZodString;
+            channelHandle: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        associations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MockSenderContext = z.infer<typeof MockSenderContextSchema>;
+export declare const MockThreadContextSchema: z.ZodObject<{
+    handle: z.ZodString;
+    model: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type MockThreadContext = z.infer<typeof MockThreadContextSchema>;
+export declare const MockContextSchema: z.ZodObject<{
+    sender: z.ZodObject<{
+        kind: z.ZodEnum<{
+            contact: "contact";
+            member: "member";
+        }>;
+        displayName: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
+        permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        contact: z.ZodOptional<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            subscription: z.ZodOptional<z.ZodObject<{
+                identifierValue: z.ZodString;
+                channelHandle: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            associations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    contexts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        handle: z.ZodString;
+        model: z.ZodString;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type MockContext = z.infer<typeof MockContextSchema>;
+/**
+ * Sandbox configuration in agent YAML
+ */
+export declare const SandboxConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    mockContext: z.ZodOptional<z.ZodObject<{
+        sender: z.ZodObject<{
+            kind: z.ZodEnum<{
+                contact: "contact";
+                member: "member";
+            }>;
+            displayName: z.ZodOptional<z.ZodString>;
+            role: z.ZodOptional<z.ZodString>;
+            permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            contact: z.ZodOptional<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                subscription: z.ZodOptional<z.ZodObject<{
+                    identifierValue: z.ZodString;
+                    channelHandle: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                associations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    id: z.ZodOptional<z.ZodString>;
+                    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        contexts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            handle: z.ZodString;
+            model: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SandboxConfig = z.infer<typeof SandboxConfigSchema>;