skedyul 1.2.41 → 1.2.44

package/dist/schemas/agent-schema-v3.mjs

@@ -0,0 +1,497 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+
+// src/schemas/agent-schema-v3.ts
+import { z as z4 } from "zod/v4";
+
+// src/events/types.ts
+import { z } from "zod/v4";
+var ThreadEventTypeSchema = z.enum([
+  // Message events
+  "thread.message.received",
+  "thread.message.sent",
+  // Participant events
+  "thread.participant.joined",
+  "thread.participant.left",
+  "thread.participant.mentioned",
+  // Context events
+  "thread.context.changed",
+  "thread.status.changed",
+  // Agent/Workflow events
+  "thread.agent.delegated",
+  "thread.agent.completed",
+  "thread.workflow.triggered",
+  "thread.workflow.completed",
+  // Scheduled events
+  "thread.follow_up.due",
+  "thread.reminder.due"
+]);
+var CustomEventTypeSchema = z.string().regex(/^custom\.[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/, {
+  message: "Custom event type must match pattern: custom.{namespace}.{event}"
+});
+var EventTypeSchema = z.union([ThreadEventTypeSchema, CustomEventTypeSchema]);
+var ParticipantKindSchema = z.enum(["CONTACT", "MEMBER", "AGENT", "WORKFLOW"]);
+var BaseEventPayloadSchema = z.object({
+  threadId: z.string(),
+  workplaceId: z.string(),
+  timestamp: z.string().datetime().optional()
+});
+var MessageEventPayloadSchema = BaseEventPayloadSchema.extend({
+  message: z.object({
+    id: z.string(),
+    content: z.string(),
+    senderId: z.string().optional()
+  }),
+  participant: z.object({
+    id: z.string(),
+    kind: ParticipantKindSchema,
+    displayName: z.string().optional()
+  }).optional(),
+  isFirstMessage: z.boolean().optional(),
+  messageCount: z.number().optional()
+});
+var ParticipantEventPayloadSchema = BaseEventPayloadSchema.extend({
+  participant: z.object({
+    id: z.string(),
+    kind: ParticipantKindSchema,
+    displayName: z.string().optional(),
+    contactId: z.string().optional(),
+    memberId: z.string().optional(),
+    agentId: z.string().optional(),
+    workflowId: z.string().optional()
+  })
+});
+var ContextChangedPayloadSchema = BaseEventPayloadSchema.extend({
+  context: z.object({
+    handle: z.string(),
+    model: z.string(),
+    instanceId: z.string()
+  }),
+  change: z.object({
+    field: z.string().optional(),
+    oldValue: z.unknown().optional(),
+    newValue: z.unknown().optional()
+  }).optional()
+});
+var StatusChangedPayloadSchema = BaseEventPayloadSchema.extend({
+  oldStatus: z.string(),
+  newStatus: z.string()
+});
+var ScheduledEventPayloadSchema = BaseEventPayloadSchema.extend({
+  scheduledEventId: z.string(),
+  reason: z.string().optional(),
+  context: z.record(z.string(), z.unknown()).optional()
+});
+var AgentWorkflowEventPayloadSchema = BaseEventPayloadSchema.extend({
+  agentId: z.string().optional(),
+  workflowId: z.string().optional(),
+  workflowRunId: z.string().optional(),
+  outputs: z.record(z.string(), z.unknown()).optional(),
+  error: z.string().optional()
+});
+var CustomEventPayloadSchema = BaseEventPayloadSchema.extend({
+  data: z.record(z.string(), z.unknown()).optional()
+});
+var ThreadEventPayloadSchema = z.union([
+  MessageEventPayloadSchema,
+  ParticipantEventPayloadSchema,
+  ContextChangedPayloadSchema,
+  StatusChangedPayloadSchema,
+  ScheduledEventPayloadSchema,
+  AgentWorkflowEventPayloadSchema,
+  CustomEventPayloadSchema
+]);
+var ThreadEventSchema = z.object({
+  id: z.string(),
+  threadId: z.string(),
+  type: EventTypeSchema,
+  payload: ThreadEventPayloadSchema,
+  emittedBy: z.string().optional(),
+  createdAt: z.string().datetime()
+});
+var CreateThreadEventInputSchema = z.object({
+  threadId: z.string(),
+  type: EventTypeSchema,
+  payload: z.record(z.string(), z.unknown()),
+  emittedBy: z.string().optional()
+});
+var EventSubscriptionSchema = z.object({
+  subscribes: z.array(EventTypeSchema),
+  condition: z.string().optional(),
+  cancels: z.array(EventTypeSchema).optional(),
+  cancelCondition: z.string().optional()
+});
+var EventWaitSchema = z.object({
+  event: EventTypeSchema,
+  timeout: z.string().optional(),
+  onTimeout: z.string().optional()
+});
+var EventsConfigSchema = z.object({
+  subscribes: z.array(EventTypeSchema).optional(),
+  condition: z.string().optional(),
+  emits: z.array(EventTypeSchema).optional(),
+  waits: z.array(EventWaitSchema).optional(),
+  cancels: z.array(EventTypeSchema).optional(),
+  cancelCondition: z.string().optional()
+});
+
+// src/skills/types.ts
+import { z as z2 } from "zod/v4";
+var SKILL_SCHEMA_VERSION_V2 = "https://skedyul.com/schemas/skill/v2";
+var SkillSourceSchema = z2.enum(["BUILTIN", "S3", "APP", "EXTERNAL"]);
+var SkillToolRequirementSchema = z2.object({
+  requires: z2.array(z2.string()).optional(),
+  provides: z2.array(z2.string()).optional()
+});
+var SkillToolSandboxSchema = z2.object({
+  mock: z2.unknown().optional()
+});
+var ToolConstraintsSchema = z2.object({
+  maxCallsPerRun: z2.number().optional(),
+  idempotent: z2.boolean().optional(),
+  restricted: z2.boolean().optional(),
+  tags: z2.array(z2.string()).optional()
+});
+var SkillToolDefinitionSchema = z2.object({
+  tool: z2.string(),
+  description: z2.string().optional(),
+  overrides: z2.record(z2.string(), z2.unknown()).optional(),
+  sandbox: SkillToolSandboxSchema.optional(),
+  requiresApproval: z2.boolean().optional(),
+  constraints: ToolConstraintsSchema.optional()
+});
+var SkillToolsSchema = z2.union([
+  SkillToolRequirementSchema,
+  z2.array(SkillToolDefinitionSchema)
+]);
+var SkillExampleSchema = z2.object({
+  context: z2.string().optional(),
+  input: z2.string(),
+  reasoning: z2.string().optional(),
+  output: z2.string(),
+  tool_call: z2.string().optional()
+});
+var SkillEvaluationMetricSchema = z2.object({
+  metric: z2.string(),
+  description: z2.string().optional(),
+  threshold: z2.number().optional()
+});
+var CRMContextSchema = z2.object({
+  models: z2.record(z2.string(), z2.array(z2.string()))
+  // { modelHandle: [fieldHandles] }
+});
+var SkillYAMLSchema = z2.object({
+  // Schema version
+  $schema: z2.string().optional(),
+  // Identity
+  handle: z2.string(),
+  name: z2.string(),
+  version: z2.string().optional(),
+  description: z2.string().optional(),
+  // Instructions injected into agent system prompt
+  instructions: z2.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: z2.array(SkillExampleSchema).optional(),
+  // Evaluation criteria
+  evaluation: z2.array(SkillEvaluationMetricSchema).optional(),
+  // Tags for discovery
+  tags: z2.array(z2.string()).optional()
+});
+var SkillYAMLV2Schema = z2.object({
+  $schema: z2.literal(SKILL_SCHEMA_VERSION_V2).optional(),
+  handle: z2.string(),
+  name: z2.string(),
+  version: z2.string().optional(),
+  description: z2.string().optional(),
+  instructions: z2.string(),
+  tools: z2.array(SkillToolDefinitionSchema).optional(),
+  crmContext: CRMContextSchema.optional(),
+  examples: z2.array(SkillExampleSchema).optional(),
+  evaluation: z2.array(SkillEvaluationMetricSchema).optional(),
+  tags: z2.array(z2.string()).optional()
+});
+var SkillVersionWeightSchema = z2.object({
+  version: z2.number(),
+  weight: z2.number()
+});
+var SkillRefSchema = z2.union([
+  z2.string(),
+  // Just handle - uses latest published version
+  z2.object({
+    skill: z2.string(),
+    description: z2.string().optional(),
+    // For AI SDK Agent Skills discovery
+    // Version selection (pick one):
+    version: z2.number().optional(),
+    // Pin to specific version number
+    versions: z2.array(SkillVersionWeightSchema).optional(),
+    // A/B testing weights
+    // Legacy support:
+    instructions: z2.string().optional(),
+    // Inline instructions (deprecated)
+    enabled: z2.boolean().optional()
+  })
+]);
+var SkillMetadataSchema = z2.object({
+  id: z2.string(),
+  handle: z2.string(),
+  name: z2.string(),
+  version: z2.string().optional(),
+  description: z2.string().optional(),
+  source: SkillSourceSchema,
+  s3Key: z2.string().optional(),
+  appVersionId: z2.string().optional(),
+  workplaceId: z2.string().optional(),
+  tags: z2.array(z2.string()).optional(),
+  createdAt: z2.string().datetime().optional(),
+  updatedAt: z2.string().datetime().optional()
+});
+var ResolvedSkillSchema = z2.object({
+  handle: z2.string(),
+  name: z2.string(),
+  instructions: z2.string().optional(),
+  description: z2.string().optional(),
+  tools: z2.array(z2.string()).optional(),
+  examples: z2.array(SkillExampleSchema).optional()
+});
+var LoadedSkillSchema = z2.object({
+  handle: z2.string(),
+  name: z2.string(),
+  instructions: z2.string().optional(),
+  description: z2.string().optional(),
+  tools: z2.array(SkillToolDefinitionSchema).optional(),
+  examples: z2.array(SkillExampleSchema).optional()
+});
+
+// src/context/types.ts
+import { z as z3 } from "zod/v4";
+var CRMContextSchema2 = z3.object({
+  model: z3.string(),
+  instanceId: z3.string(),
+  data: z3.record(z3.string(), z3.unknown())
+});
+var SenderContextSchema = z3.object({
+  kind: ParticipantKindSchema,
+  displayName: z3.string().optional(),
+  email: z3.string().optional(),
+  role: z3.string().optional(),
+  permissions: z3.array(z3.string()).optional(),
+  crm: CRMContextSchema2.optional()
+});
+var ThreadContextItemSchema = z3.object({
+  handle: z3.string(),
+  model: z3.string(),
+  instanceId: z3.string(),
+  data: z3.record(z3.string(), z3.unknown()).optional()
+});
+var ThreadInfoSchema = z3.object({
+  id: z3.string(),
+  title: z3.string().optional(),
+  status: z3.string().optional(),
+  kind: z3.string().optional()
+});
+var AgentContextSchema = z3.object({
+  // Who sent the message
+  sender: SenderContextSchema,
+  // Thread contexts (linked CRM instances)
+  contexts: z3.array(ThreadContextItemSchema).optional(),
+  // Thread info
+  thread: ThreadInfoSchema,
+  // Workplace info
+  workplace: z3.object({
+    id: z3.string(),
+    name: z3.string().optional()
+  }).optional()
+});
+var MockSubscriptionSchema = z3.object({
+  identifierValue: z3.string(),
+  channelHandle: z3.string().optional()
+});
+var MockAssociationSchema = z3.object({
+  id: z3.string().optional(),
+  data: z3.record(z3.string(), z3.unknown())
+});
+var MockContactSchema = z3.object({
+  id: z3.string().optional(),
+  name: z3.string().optional(),
+  subscription: MockSubscriptionSchema.optional(),
+  associations: z3.record(z3.string(), MockAssociationSchema).optional()
+});
+var MockSenderContextSchema = z3.object({
+  kind: z3.enum(["contact", "member"]),
+  displayName: z3.string().optional(),
+  role: z3.string().optional(),
+  permissions: z3.array(z3.string()).optional(),
+  contact: MockContactSchema.optional()
+});
+var MockThreadContextSchema = z3.object({
+  handle: z3.string(),
+  model: z3.string(),
+  data: z3.record(z3.string(), z3.unknown())
+});
+var MockContextSchema = z3.object({
+  sender: MockSenderContextSchema,
+  contexts: z3.array(MockThreadContextSchema).optional()
+});
+var SandboxConfigSchema = z3.object({
+  enabled: z3.boolean().optional(),
+  mockContext: MockContextSchema.optional()
+});
+
+// src/schemas/agent-schema-v3.ts
+var AGENT_SCHEMA_VERSION_V3 = "https://skedyul.com/schemas/agent/v3";
+var PersonaVoiceFormatV3Schema = z4.object({
+  maxChars: z4.number().optional(),
+  noEmojis: z4.boolean().optional(),
+  noHyphens: z4.boolean().optional(),
+  noBulletPoints: z4.boolean().optional(),
+  maxQuestionsPerMessage: z4.number().optional(),
+  noSignOffs: z4.boolean().optional()
+});
+var PersonaVoiceV3Schema = z4.object({
+  style: z4.string(),
+  format: PersonaVoiceFormatV3Schema.optional()
+});
+var PersonaV3Schema = z4.object({
+  name: z4.string(),
+  voice: PersonaVoiceV3Schema
+});
+var ToolApprovalConfigSchema = z4.object({
+  required: z4.boolean().optional(),
+  requiredIf: z4.array(z4.string()).optional()
+});
+var ToolSandboxConfigSchema = z4.object({
+  mock: z4.unknown().optional()
+});
+var ToolRefV3Schema = z4.union([
+  z4.string(),
+  z4.object({
+    tool: z4.string(),
+    description: z4.string().optional(),
+    approval: ToolApprovalConfigSchema.optional(),
+    sandbox: ToolSandboxConfigSchema.optional(),
+    overrides: z4.record(z4.string(), z4.unknown()).optional()
+  })
+]);
+var BootstrapToolRefSchema = z4.union([
+  z4.string(),
+  z4.object({
+    tool: z4.string(),
+    description: z4.string().optional()
+  })
+]);
+var WorkingMemoryConfigSchema = z4.object({
+  strategy: z4.enum(["full", "rolling_summary", "sliding_window"]).optional(),
+  maxTokens: z4.number().optional(),
+  summarizeAt: z4.number().optional()
+});
+var ExternalMemoryConfigSchema = z4.object({
+  enabled: z4.boolean().optional(),
+  ttl: z4.string().optional()
+});
+var SemanticMemoryConfigSchema = z4.object({
+  enabled: z4.boolean().optional(),
+  topK: z4.number().optional(),
+  scope: z4.enum(["thread", "instance", "workspace"]).optional()
+});
+var MemoryConfigV3Schema = z4.object({
+  working: WorkingMemoryConfigSchema.optional(),
+  persistent: z4.object({
+    namespace: z4.string().optional()
+  }).optional(),
+  external: ExternalMemoryConfigSchema.optional(),
+  semantic: SemanticMemoryConfigSchema.optional()
+});
+var ResponsePolicySchema = z4.object({
+  requiresApproval: z4.boolean().optional(),
+  requiresApprovalIf: z4.array(z4.string()).optional()
+});
+var PoliciesConfigV3Schema = z4.object({
+  response: ResponsePolicySchema.optional(),
+  rules: z4.array(z4.string()).optional()
+});
+var RuntimeConfigV3Schema = z4.object({
+  model: z4.string().optional(),
+  timeout: z4.string().optional(),
+  timezone: z4.string().optional(),
+  retry: z4.object({
+    attempts: z4.number().optional(),
+    backoff: z4.enum(["linear", "exponential"]).optional()
+  }).optional()
+});
+var PromptsConfigV3Schema = z4.object({
+  recovery: z4.string().optional(),
+  followUp: z4.string().optional(),
+  skillDiscoveryWorkflow: z4.string().optional()
+});
+var AgentConfigV3Schema = z4.record(z4.string(), z4.unknown());
+var AgentYAMLV3Schema = z4.object({
+  $schema: z4.string().optional(),
+  handle: z4.string(),
+  name: z4.string(),
+  version: z4.string().optional(),
+  description: z4.string().optional(),
+  // Persona - Who the agent is
+  persona: PersonaV3Schema.optional(),
+  // Skills - What the agent knows how to do (skills own their tools)
+  skills: z4.array(SkillRefSchema).optional(),
+  // Bootstrap tools - Always-available system tools before any skill loads
+  // Examples: system:skill:load, system:message:send
+  bootstrapTools: z4.array(BootstrapToolRefSchema).optional(),
+  // Tools - DEPRECATED: Use skills to own tools instead
+  // Kept for backward compatibility during migration
+  // @deprecated Will be removed in a future version
+  tools: z4.array(ToolRefV3Schema).optional(),
+  // Events - When the agent activates
+  events: EventsConfigSchema.optional(),
+  // Memory - How the agent remembers
+  memory: MemoryConfigV3Schema.optional(),
+  // Policies - Constraints and approvals
+  policies: PoliciesConfigV3Schema.optional(),
+  // Runtime - Execution configuration
+  runtime: RuntimeConfigV3Schema.optional(),
+  // Prompts - Agent-specific prompt injections for runtime phases
+  // recovery: Injected during second pass when skills were loaded but tools not used
+  // followUp: Injected during follow-up passes when context needs updating
+  // skillDiscoveryWorkflow: Custom workflow instructions for skill discovery
+  prompts: PromptsConfigV3Schema.optional(),
+  // Config - Business-specific settings
+  config: AgentConfigV3Schema.optional(),
+  // Sandbox - Testing configuration
+  sandbox: SandboxConfigSchema.optional()
+});
+function defineAgentV3(agent) {
+  return AgentYAMLV3Schema.parse(agent);
+}
+function validateAgentYAMLV3(agent) {
+  const result = AgentYAMLV3Schema.safeParse(agent);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+export {
+  AGENT_SCHEMA_VERSION_V3,
+  AgentConfigV3Schema,
+  AgentYAMLV3Schema,
+  BootstrapToolRefSchema,
+  ExternalMemoryConfigSchema,
+  MemoryConfigV3Schema,
+  PersonaV3Schema,
+  PersonaVoiceFormatV3Schema,
+  PersonaVoiceV3Schema,
+  PoliciesConfigV3Schema,
+  PromptsConfigV3Schema,
+  ResponsePolicySchema,
+  RuntimeConfigV3Schema,
+  SemanticMemoryConfigSchema,
+  ToolApprovalConfigSchema,
+  ToolRefV3Schema,
+  ToolSandboxConfigSchema,
+  WorkingMemoryConfigSchema,
+  defineAgentV3,
+  validateAgentYAMLV3
+};