skedyul 1.2.41 → 1.2.43

package/dist/skills/types.mjs

@@ -0,0 +1,234 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+
+// src/skills/types.ts
+import { z } from "zod/v4";
+var SKILL_SCHEMA_VERSION = "https://skedyul.com/schemas/skill/v1";
+var SKILL_SCHEMA_VERSION_V2 = "https://skedyul.com/schemas/skill/v2";
+var SkillSourceSchema = z.enum(["BUILTIN", "S3", "APP", "EXTERNAL"]);
+var SkillToolRequirementSchema = z.object({
+  requires: z.array(z.string()).optional(),
+  provides: z.array(z.string()).optional()
+});
+var SkillToolSandboxSchema = z.object({
+  mock: z.unknown().optional()
+});
+var ToolConstraintsSchema = z.object({
+  maxCallsPerRun: z.number().optional(),
+  idempotent: z.boolean().optional(),
+  restricted: z.boolean().optional(),
+  tags: z.array(z.string()).optional()
+});
+var SkillToolDefinitionSchema = z.object({
+  tool: z.string(),
+  description: z.string().optional(),
+  overrides: z.record(z.string(), z.unknown()).optional(),
+  sandbox: SkillToolSandboxSchema.optional(),
+  requiresApproval: z.boolean().optional(),
+  constraints: ToolConstraintsSchema.optional()
+});
+var SkillToolsSchema = z.union([
+  SkillToolRequirementSchema,
+  z.array(SkillToolDefinitionSchema)
+]);
+var SkillExampleSchema = z.object({
+  context: z.string().optional(),
+  input: z.string(),
+  reasoning: z.string().optional(),
+  output: z.string(),
+  tool_call: z.string().optional()
+});
+var SkillEvaluationMetricSchema = z.object({
+  metric: z.string(),
+  description: z.string().optional(),
+  threshold: z.number().optional()
+});
+var CRMContextSchema = z.object({
+  models: z.record(z.string(), z.array(z.string()))
+  // { modelHandle: [fieldHandles] }
+});
+var SkillYAMLSchema = z.object({
+  // Schema version
+  $schema: z.string().optional(),
+  // Identity
+  handle: z.string(),
+  name: z.string(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  // Instructions injected into agent system prompt
+  instructions: z.string(),
+  // Tool configuration - supports both v1 and v2 formats
+  tools: SkillToolsSchema.optional(),
+  // CRM context - specifies which models/fields to include in schema
+  crmContext: CRMContextSchema.optional(),
+  // Few-shot examples
+  examples: z.array(SkillExampleSchema).optional(),
+  // Evaluation criteria
+  evaluation: z.array(SkillEvaluationMetricSchema).optional(),
+  // Tags for discovery
+  tags: z.array(z.string()).optional()
+});
+var SkillYAMLV2Schema = z.object({
+  $schema: z.literal(SKILL_SCHEMA_VERSION_V2).optional(),
+  handle: z.string(),
+  name: z.string(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  instructions: z.string(),
+  tools: z.array(SkillToolDefinitionSchema).optional(),
+  crmContext: CRMContextSchema.optional(),
+  examples: z.array(SkillExampleSchema).optional(),
+  evaluation: z.array(SkillEvaluationMetricSchema).optional(),
+  tags: z.array(z.string()).optional()
+});
+var SkillVersionWeightSchema = z.object({
+  version: z.number(),
+  weight: z.number()
+});
+var SkillRefSchema = z.union([
+  z.string(),
+  // Just handle - uses latest published version
+  z.object({
+    skill: z.string(),
+    description: z.string().optional(),
+    // For AI SDK Agent Skills discovery
+    // Version selection (pick one):
+    version: z.number().optional(),
+    // Pin to specific version number
+    versions: z.array(SkillVersionWeightSchema).optional(),
+    // A/B testing weights
+    // Legacy support:
+    instructions: z.string().optional(),
+    // Inline instructions (deprecated)
+    enabled: z.boolean().optional()
+  })
+]);
+var SkillMetadataSchema = z.object({
+  id: z.string(),
+  handle: z.string(),
+  name: z.string(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  source: SkillSourceSchema,
+  s3Key: z.string().optional(),
+  appVersionId: z.string().optional(),
+  workplaceId: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  createdAt: z.string().datetime().optional(),
+  updatedAt: z.string().datetime().optional()
+});
+var ResolvedSkillSchema = z.object({
+  handle: z.string(),
+  name: z.string(),
+  instructions: z.string().optional(),
+  description: z.string().optional(),
+  tools: z.array(z.string()).optional(),
+  examples: z.array(SkillExampleSchema).optional()
+});
+var LoadedSkillSchema = z.object({
+  handle: z.string(),
+  name: z.string(),
+  instructions: z.string().optional(),
+  description: z.string().optional(),
+  tools: z.array(SkillToolDefinitionSchema).optional(),
+  examples: z.array(SkillExampleSchema).optional()
+});
+function isV2SkillTools(tools) {
+  if (!tools) return false;
+  return Array.isArray(tools);
+}
+function getSkillToolNames(tools) {
+  if (!tools) return [];
+  if (isV2SkillTools(tools)) {
+    return tools.map((t) => t.tool);
+  }
+  return tools.requires || [];
+}
+function convertV1ToV2Tools(requires) {
+  return requires.map((tool) => ({ tool }));
+}
+function defineSkill(skill) {
+  return SkillYAMLSchema.parse(skill);
+}
+function validateSkillYAML(skill) {
+  const result = SkillYAMLSchema.safeParse(skill);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+function formatSkillInstructions(skills) {
+  if (skills.length === 0) return "";
+  const sections = skills.map((skill) => {
+    if (!skill.instructions) {
+      return `## ${skill.name}
+
+${skill.description || "No description available."}`;
+    }
+    let section = `## ${skill.name}
+
+${skill.instructions}`;
+    if (skill.examples && skill.examples.length > 0) {
+      section += "\n\n### Examples\n";
+      for (const example of skill.examples) {
+        section += `
+**Input:** ${example.input}
+`;
+        if (example.reasoning) {
+          section += `**Reasoning:** ${example.reasoning}
+`;
+        }
+        section += `**Output:** ${example.output}
+`;
+      }
+    }
+    return section;
+  });
+  return `# Skills
+
+${sections.join("\n\n---\n\n")}`;
+}
+function formatSkillDiscovery(skills, workflowInstructions) {
+  if (skills.length === 0) return "";
+  const skillsList = skills.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+  const defaultWorkflow = `WORKFLOW FOR EVERY RESPONSE:
+1. Check the Current Context data to understand the current state
+2. Read the skill descriptions below - each tells you WHEN to use it
+3. Load the matching skill using \`system:skill:load\`
+4. Follow the skill's instructions exactly`;
+  const workflow = workflowInstructions ?? defaultWorkflow;
+  return `## Skills
+
+${workflow}
+
+Available skills:
+${skillsList}
+
+IMPORTANT: Always use the proper tool calls. Do NOT output XML-like tags in your response.`;
+}
+export {
+  CRMContextSchema,
+  LoadedSkillSchema,
+  ResolvedSkillSchema,
+  SKILL_SCHEMA_VERSION,
+  SKILL_SCHEMA_VERSION_V2,
+  SkillEvaluationMetricSchema,
+  SkillExampleSchema,
+  SkillMetadataSchema,
+  SkillRefSchema,
+  SkillSourceSchema,
+  SkillToolDefinitionSchema,
+  SkillToolRequirementSchema,
+  SkillToolSandboxSchema,
+  SkillToolsSchema,
+  SkillVersionWeightSchema,
+  SkillYAMLSchema,
+  SkillYAMLV2Schema,
+  ToolConstraintsSchema,
+  convertV1ToV2Tools,
+  defineSkill,
+  formatSkillDiscovery,
+  formatSkillInstructions,
+  getSkillToolNames,
+  isV2SkillTools,
+  validateSkillYAML
+};

package/dist/triggers/index.d.ts

@@ -0,0 +1,2 @@
+export { CRMDataSchema, SenderContextSchema, ThreadContextItemSchema, ParticipantContextSchema, TriggerContextSchema, InputMappingSchema, EventConditionsSchema, TriggerConfigSchema, ResolvedTriggerSchema, WorkflowInputDefinitionSchema, WorkflowInputSchemaSchema, TriggerResolutionError, type CRMData, type SenderContext, type ThreadContextItem, type ParticipantContext, type TriggerContext, type InputMapping, type EventConditions, type TriggerConfig, type ResolvedTrigger, type WorkflowInputDefinition, type WorkflowInputSchema, } from './types';
+export { evaluateTemplate, evaluateCondition, resolveInputMappings, matchesTrigger, } from './resolver';

package/dist/triggers/resolver.d.ts

@@ -0,0 +1,31 @@
+import type { TriggerContext, InputMapping, WorkflowInputSchema } from './types';
+/**
+ * Simple Liquid-like template evaluation
+ * Supports basic property access: {{ thread.sender.crm.email }}
+ *
+ * For production, consider using a proper Liquid library like liquidjs
+ */
+export declare function evaluateTemplate(template: string, context: TriggerContext): unknown;
+/**
+ * Evaluate a condition expression against context
+ * Supports basic comparisons: {{ event.participant.kind == 'CONTACT' }}
+ *
+ * For production, consider using a proper expression evaluator
+ */
+export declare function evaluateCondition(condition: string, context: TriggerContext): boolean;
+/**
+ * Resolve input mappings against trigger context
+ */
+export declare function resolveInputMappings(mappings: InputMapping, inputSchema: WorkflowInputSchema | undefined, context: TriggerContext): Promise<Record<string, unknown>>;
+/**
+ * Check if a trigger matches an event based on subscriptions and conditions
+ */
+export declare function matchesTrigger(trigger: {
+    workflow?: {
+        events?: {
+            subscribes?: string[];
+            condition?: string;
+        };
+    };
+    eventConditions?: Record<string, string>;
+}, eventType: string, context: TriggerContext): boolean;

package/dist/triggers/types.d.ts

@@ -0,0 +1,313 @@
+import { z } from 'zod/v4';
+/**
+ * CRM data structure for context resolution
+ */
+export declare const CRMDataSchema: z.ZodObject<{
+    model: z.ZodString;
+    instanceId: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type CRMData = z.infer<typeof CRMDataSchema>;
+/**
+ * Sender context - who sent the triggering message/event
+ */
+export declare const SenderContextSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        CONTACT: "CONTACT";
+        MEMBER: "MEMBER";
+        AGENT: "AGENT";
+        WORKFLOW: "WORKFLOW";
+    }>;
+    displayName: z.ZodOptional<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 - linked CRM instances
+ */
+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>;
+/**
+ * Participant in thread context
+ */
+export declare const ParticipantContextSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        CONTACT: "CONTACT";
+        MEMBER: "MEMBER";
+        AGENT: "AGENT";
+        WORKFLOW: "WORKFLOW";
+    }>;
+    displayName: z.ZodOptional<z.ZodString>;
+    contactId: z.ZodOptional<z.ZodString>;
+    memberId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+    workflowId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ParticipantContext = z.infer<typeof ParticipantContextSchema>;
+/**
+ * Full trigger context - available for input mapping evaluation
+ */
+export declare const TriggerContextSchema: z.ZodObject<{
+    event: z.ZodObject<{
+        type: z.ZodUnion<readonly [z.ZodEnum<{
+            "thread.message.received": "thread.message.received";
+            "thread.message.sent": "thread.message.sent";
+            "thread.participant.joined": "thread.participant.joined";
+            "thread.participant.left": "thread.participant.left";
+            "thread.participant.mentioned": "thread.participant.mentioned";
+            "thread.context.changed": "thread.context.changed";
+            "thread.status.changed": "thread.status.changed";
+            "thread.agent.delegated": "thread.agent.delegated";
+            "thread.agent.completed": "thread.agent.completed";
+            "thread.workflow.triggered": "thread.workflow.triggered";
+            "thread.workflow.completed": "thread.workflow.completed";
+            "thread.follow_up.due": "thread.follow_up.due";
+            "thread.reminder.due": "thread.reminder.due";
+        }>, z.ZodString]>;
+        payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        participant: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                CONTACT: "CONTACT";
+                MEMBER: "MEMBER";
+                AGENT: "AGENT";
+                WORKFLOW: "WORKFLOW";
+            }>;
+            displayName: z.ZodOptional<z.ZodString>;
+            contactId: z.ZodOptional<z.ZodString>;
+            memberId: z.ZodOptional<z.ZodString>;
+            agentId: z.ZodOptional<z.ZodString>;
+            workflowId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    thread: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+        sender: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                CONTACT: "CONTACT";
+                MEMBER: "MEMBER";
+                AGENT: "AGENT";
+                WORKFLOW: "WORKFLOW";
+            }>;
+            displayName: z.ZodOptional<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>>;
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodString;
+            instanceId: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>>;
+        participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                CONTACT: "CONTACT";
+                MEMBER: "MEMBER";
+                AGENT: "AGENT";
+                WORKFLOW: "WORKFLOW";
+            }>;
+            displayName: z.ZodOptional<z.ZodString>;
+            contactId: z.ZodOptional<z.ZodString>;
+            memberId: z.ZodOptional<z.ZodString>;
+            agentId: z.ZodOptional<z.ZodString>;
+            workflowId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    workplace: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TriggerContext = z.infer<typeof TriggerContextSchema>;
+/**
+ * Input mapping - Liquid template string that resolves to a value
+ * e.g., "{{ thread.sender.crm }}" or "{{ thread.context.Customer }}"
+ */
+export declare const InputMappingSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export type InputMapping = z.infer<typeof InputMappingSchema>;
+/**
+ * Event conditions - per-event-type conditions
+ * e.g., { "thread.participant.joined": "{{ event.participant.kind == 'CONTACT' }}" }
+ */
+export declare const EventConditionsSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export type EventConditions = z.infer<typeof EventConditionsSchema>;
+/**
+ * Trigger configuration (stored in database)
+ */
+export declare const TriggerConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    workflowId: z.ZodString;
+    workflowVersionId: z.ZodOptional<z.ZodString>;
+    workplaceId: z.ZodString;
+    handle: z.ZodString;
+    inputMappings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    eventConditions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodOptional<z.ZodString>;
+    isEnabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type TriggerConfig = z.infer<typeof TriggerConfigSchema>;
+/**
+ * Resolved trigger - after input mappings have been evaluated
+ */
+export declare const ResolvedTriggerSchema: z.ZodObject<{
+    trigger: z.ZodObject<{
+        id: z.ZodString;
+        workflowId: z.ZodString;
+        workflowVersionId: z.ZodOptional<z.ZodString>;
+        workplaceId: z.ZodString;
+        handle: z.ZodString;
+        inputMappings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        eventConditions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        type: z.ZodOptional<z.ZodString>;
+        isEnabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    workflow: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        events: z.ZodOptional<z.ZodObject<{
+            subscribes: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                "thread.message.received": "thread.message.received";
+                "thread.message.sent": "thread.message.sent";
+                "thread.participant.joined": "thread.participant.joined";
+                "thread.participant.left": "thread.participant.left";
+                "thread.participant.mentioned": "thread.participant.mentioned";
+                "thread.context.changed": "thread.context.changed";
+                "thread.status.changed": "thread.status.changed";
+                "thread.agent.delegated": "thread.agent.delegated";
+                "thread.agent.completed": "thread.agent.completed";
+                "thread.workflow.triggered": "thread.workflow.triggered";
+                "thread.workflow.completed": "thread.workflow.completed";
+                "thread.follow_up.due": "thread.follow_up.due";
+                "thread.reminder.due": "thread.reminder.due";
+            }>, z.ZodString]>>>;
+            condition: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    inputs: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    context: z.ZodObject<{
+        event: z.ZodObject<{
+            type: z.ZodUnion<readonly [z.ZodEnum<{
+                "thread.message.received": "thread.message.received";
+                "thread.message.sent": "thread.message.sent";
+                "thread.participant.joined": "thread.participant.joined";
+                "thread.participant.left": "thread.participant.left";
+                "thread.participant.mentioned": "thread.participant.mentioned";
+                "thread.context.changed": "thread.context.changed";
+                "thread.status.changed": "thread.status.changed";
+                "thread.agent.delegated": "thread.agent.delegated";
+                "thread.agent.completed": "thread.agent.completed";
+                "thread.workflow.triggered": "thread.workflow.triggered";
+                "thread.workflow.completed": "thread.workflow.completed";
+                "thread.follow_up.due": "thread.follow_up.due";
+                "thread.reminder.due": "thread.reminder.due";
+            }>, z.ZodString]>;
+            payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            participant: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    CONTACT: "CONTACT";
+                    MEMBER: "MEMBER";
+                    AGENT: "AGENT";
+                    WORKFLOW: "WORKFLOW";
+                }>;
+                displayName: z.ZodOptional<z.ZodString>;
+                contactId: z.ZodOptional<z.ZodString>;
+                memberId: z.ZodOptional<z.ZodString>;
+                agentId: z.ZodOptional<z.ZodString>;
+                workflowId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        thread: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodString>;
+            sender: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    CONTACT: "CONTACT";
+                    MEMBER: "MEMBER";
+                    AGENT: "AGENT";
+                    WORKFLOW: "WORKFLOW";
+                }>;
+                displayName: z.ZodOptional<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>>;
+            context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                model: z.ZodString;
+                instanceId: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>>>;
+            participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    CONTACT: "CONTACT";
+                    MEMBER: "MEMBER";
+                    AGENT: "AGENT";
+                    WORKFLOW: "WORKFLOW";
+                }>;
+                displayName: z.ZodOptional<z.ZodString>;
+                contactId: z.ZodOptional<z.ZodString>;
+                memberId: z.ZodOptional<z.ZodString>;
+                agentId: z.ZodOptional<z.ZodString>;
+                workflowId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        workplace: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ResolvedTrigger = z.infer<typeof ResolvedTriggerSchema>;
+/**
+ * Trigger resolution error
+ */
+export declare class TriggerResolutionError extends Error {
+    readonly triggerId?: string | undefined;
+    readonly inputName?: string | undefined;
+    constructor(message: string, triggerId?: string | undefined, inputName?: string | undefined);
+}
+/**
+ * Workflow input schema definition
+ */
+export declare const WorkflowInputDefinitionSchema: z.ZodObject<{
+    type: z.ZodString;
+    required: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type WorkflowInputDefinition = z.infer<typeof WorkflowInputDefinitionSchema>;
+/**
+ * Workflow input schema (map of input name to definition)
+ */
+export declare const WorkflowInputSchemaSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodString;
+    required: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>>;
+export type WorkflowInputSchema = z.infer<typeof WorkflowInputSchemaSchema>;

package/dist/types/data-blocks.d.ts

@@ -0,0 +1,105 @@
+/**
+ * DataBlock types for rich UI rendering of tool results.
+ * Apps can include dataBlocks in their tool responses to control
+ * how results are displayed in the agent chat UI.
+ */
+/**
+ * Link structure for navigating to CRM views or external URLs.
+ */
+export interface DataBlockLink {
+    modelHandle?: string;
+    modelHandlePlural?: string;
+    modelLabel?: string;
+    recordId?: string;
+    filters?: Record<string, unknown>;
+    url?: string;
+}
+/**
+ * Column definition for spreadsheet blocks.
+ */
+export interface SpreadsheetColumn {
+    id: string;
+    label: string;
+    type?: string;
+}
+/**
+ * Spreadsheet block - tabular data with preview rows.
+ */
+export interface SpreadsheetBlock {
+    type: 'spreadsheet';
+    title: string;
+    columns: SpreadsheetColumn[];
+    data: Array<{
+        id: string;
+        [key: string]: unknown;
+    }>;
+    totalRows: number;
+    link?: DataBlockLink;
+}
+/**
+ * Avatar configuration for profile blocks.
+ */
+export interface ProfileAvatar {
+    initials?: string;
+    imageUrl?: string;
+}
+/**
+ * Field entry for profile blocks.
+ */
+export interface ProfileField {
+    label: string;
+    value: string;
+}
+/**
+ * Profile block - entity card with key fields.
+ */
+export interface ProfileBlock {
+    type: 'profile';
+    title: string;
+    subtitle?: string;
+    avatar?: ProfileAvatar;
+    fields: ProfileField[];
+    link?: DataBlockLink;
+}
+/**
+ * Field change entry showing old → new value transition.
+ */
+export interface FieldChangeItem {
+    label: string;
+    oldValue: string | null;
+    newValue: string | null;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Field changes block - shows old → new value transitions.
+ */
+export interface FieldChangesBlock {
+    type: 'fieldChanges';
+    title: string;
+    subtitle?: string;
+    changes: FieldChangeItem[];
+    link?: DataBlockLink;
+}
+/**
+ * DateTime block - shows a calendar event/appointment with status.
+ */
+export interface DateTimeBlock {
+    type: 'dateTime';
+    title: string;
+    subtitle?: string;
+    datetime: string;
+    timezone?: string;
+    duration?: number;
+    location?: string;
+    status?: 'confirmed' | 'pending' | 'cancelled';
+    icon?: 'calendar' | 'clock' | 'check';
+    link?: DataBlockLink;
+}
+/**
+ * Union of all data block types.
+ * Tools can return these in their results to be forwarded to the UI.
+ */
+export type DataBlock = SpreadsheetBlock | ProfileBlock | FieldChangesBlock | DateTimeBlock;