skedyul 1.2.41 → 1.2.44

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

@@ -0,0 +1,539 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/schemas/agent-schema-v3.ts
+var agent_schema_v3_exports = {};
+__export(agent_schema_v3_exports, {
+  AGENT_SCHEMA_VERSION_V3: () => AGENT_SCHEMA_VERSION_V3,
+  AgentConfigV3Schema: () => AgentConfigV3Schema,
+  AgentYAMLV3Schema: () => AgentYAMLV3Schema,
+  BootstrapToolRefSchema: () => BootstrapToolRefSchema,
+  ExternalMemoryConfigSchema: () => ExternalMemoryConfigSchema,
+  MemoryConfigV3Schema: () => MemoryConfigV3Schema,
+  PersonaV3Schema: () => PersonaV3Schema,
+  PersonaVoiceFormatV3Schema: () => PersonaVoiceFormatV3Schema,
+  PersonaVoiceV3Schema: () => PersonaVoiceV3Schema,
+  PoliciesConfigV3Schema: () => PoliciesConfigV3Schema,
+  PromptsConfigV3Schema: () => PromptsConfigV3Schema,
+  ResponsePolicySchema: () => ResponsePolicySchema,
+  RuntimeConfigV3Schema: () => RuntimeConfigV3Schema,
+  SemanticMemoryConfigSchema: () => SemanticMemoryConfigSchema,
+  ToolApprovalConfigSchema: () => ToolApprovalConfigSchema,
+  ToolRefV3Schema: () => ToolRefV3Schema,
+  ToolSandboxConfigSchema: () => ToolSandboxConfigSchema,
+  WorkingMemoryConfigSchema: () => WorkingMemoryConfigSchema,
+  defineAgentV3: () => defineAgentV3,
+  validateAgentYAMLV3: () => validateAgentYAMLV3
+});
+module.exports = __toCommonJS(agent_schema_v3_exports);
+var import_v44 = require("zod/v4");
+
+// src/events/types.ts
+var import_v4 = require("zod/v4");
+var ThreadEventTypeSchema = import_v4.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 = import_v4.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 = import_v4.z.union([ThreadEventTypeSchema, CustomEventTypeSchema]);
+var ParticipantKindSchema = import_v4.z.enum(["CONTACT", "MEMBER", "AGENT", "WORKFLOW"]);
+var BaseEventPayloadSchema = import_v4.z.object({
+  threadId: import_v4.z.string(),
+  workplaceId: import_v4.z.string(),
+  timestamp: import_v4.z.string().datetime().optional()
+});
+var MessageEventPayloadSchema = BaseEventPayloadSchema.extend({
+  message: import_v4.z.object({
+    id: import_v4.z.string(),
+    content: import_v4.z.string(),
+    senderId: import_v4.z.string().optional()
+  }),
+  participant: import_v4.z.object({
+    id: import_v4.z.string(),
+    kind: ParticipantKindSchema,
+    displayName: import_v4.z.string().optional()
+  }).optional(),
+  isFirstMessage: import_v4.z.boolean().optional(),
+  messageCount: import_v4.z.number().optional()
+});
+var ParticipantEventPayloadSchema = BaseEventPayloadSchema.extend({
+  participant: import_v4.z.object({
+    id: import_v4.z.string(),
+    kind: ParticipantKindSchema,
+    displayName: import_v4.z.string().optional(),
+    contactId: import_v4.z.string().optional(),
+    memberId: import_v4.z.string().optional(),
+    agentId: import_v4.z.string().optional(),
+    workflowId: import_v4.z.string().optional()
+  })
+});
+var ContextChangedPayloadSchema = BaseEventPayloadSchema.extend({
+  context: import_v4.z.object({
+    handle: import_v4.z.string(),
+    model: import_v4.z.string(),
+    instanceId: import_v4.z.string()
+  }),
+  change: import_v4.z.object({
+    field: import_v4.z.string().optional(),
+    oldValue: import_v4.z.unknown().optional(),
+    newValue: import_v4.z.unknown().optional()
+  }).optional()
+});
+var StatusChangedPayloadSchema = BaseEventPayloadSchema.extend({
+  oldStatus: import_v4.z.string(),
+  newStatus: import_v4.z.string()
+});
+var ScheduledEventPayloadSchema = BaseEventPayloadSchema.extend({
+  scheduledEventId: import_v4.z.string(),
+  reason: import_v4.z.string().optional(),
+  context: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()).optional()
+});
+var AgentWorkflowEventPayloadSchema = BaseEventPayloadSchema.extend({
+  agentId: import_v4.z.string().optional(),
+  workflowId: import_v4.z.string().optional(),
+  workflowRunId: import_v4.z.string().optional(),
+  outputs: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()).optional(),
+  error: import_v4.z.string().optional()
+});
+var CustomEventPayloadSchema = BaseEventPayloadSchema.extend({
+  data: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()).optional()
+});
+var ThreadEventPayloadSchema = import_v4.z.union([
+  MessageEventPayloadSchema,
+  ParticipantEventPayloadSchema,
+  ContextChangedPayloadSchema,
+  StatusChangedPayloadSchema,
+  ScheduledEventPayloadSchema,
+  AgentWorkflowEventPayloadSchema,
+  CustomEventPayloadSchema
+]);
+var ThreadEventSchema = import_v4.z.object({
+  id: import_v4.z.string(),
+  threadId: import_v4.z.string(),
+  type: EventTypeSchema,
+  payload: ThreadEventPayloadSchema,
+  emittedBy: import_v4.z.string().optional(),
+  createdAt: import_v4.z.string().datetime()
+});
+var CreateThreadEventInputSchema = import_v4.z.object({
+  threadId: import_v4.z.string(),
+  type: EventTypeSchema,
+  payload: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()),
+  emittedBy: import_v4.z.string().optional()
+});
+var EventSubscriptionSchema = import_v4.z.object({
+  subscribes: import_v4.z.array(EventTypeSchema),
+  condition: import_v4.z.string().optional(),
+  cancels: import_v4.z.array(EventTypeSchema).optional(),
+  cancelCondition: import_v4.z.string().optional()
+});
+var EventWaitSchema = import_v4.z.object({
+  event: EventTypeSchema,
+  timeout: import_v4.z.string().optional(),
+  onTimeout: import_v4.z.string().optional()
+});
+var EventsConfigSchema = import_v4.z.object({
+  subscribes: import_v4.z.array(EventTypeSchema).optional(),
+  condition: import_v4.z.string().optional(),
+  emits: import_v4.z.array(EventTypeSchema).optional(),
+  waits: import_v4.z.array(EventWaitSchema).optional(),
+  cancels: import_v4.z.array(EventTypeSchema).optional(),
+  cancelCondition: import_v4.z.string().optional()
+});
+
+// src/skills/types.ts
+var import_v42 = require("zod/v4");
+var SKILL_SCHEMA_VERSION_V2 = "https://skedyul.com/schemas/skill/v2";
+var SkillSourceSchema = import_v42.z.enum(["BUILTIN", "S3", "APP", "EXTERNAL"]);
+var SkillToolRequirementSchema = import_v42.z.object({
+  requires: import_v42.z.array(import_v42.z.string()).optional(),
+  provides: import_v42.z.array(import_v42.z.string()).optional()
+});
+var SkillToolSandboxSchema = import_v42.z.object({
+  mock: import_v42.z.unknown().optional()
+});
+var ToolConstraintsSchema = import_v42.z.object({
+  maxCallsPerRun: import_v42.z.number().optional(),
+  idempotent: import_v42.z.boolean().optional(),
+  restricted: import_v42.z.boolean().optional(),
+  tags: import_v42.z.array(import_v42.z.string()).optional()
+});
+var SkillToolDefinitionSchema = import_v42.z.object({
+  tool: import_v42.z.string(),
+  description: import_v42.z.string().optional(),
+  overrides: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()).optional(),
+  sandbox: SkillToolSandboxSchema.optional(),
+  requiresApproval: import_v42.z.boolean().optional(),
+  constraints: ToolConstraintsSchema.optional()
+});
+var SkillToolsSchema = import_v42.z.union([
+  SkillToolRequirementSchema,
+  import_v42.z.array(SkillToolDefinitionSchema)
+]);
+var SkillExampleSchema = import_v42.z.object({
+  context: import_v42.z.string().optional(),
+  input: import_v42.z.string(),
+  reasoning: import_v42.z.string().optional(),
+  output: import_v42.z.string(),
+  tool_call: import_v42.z.string().optional()
+});
+var SkillEvaluationMetricSchema = import_v42.z.object({
+  metric: import_v42.z.string(),
+  description: import_v42.z.string().optional(),
+  threshold: import_v42.z.number().optional()
+});
+var CRMContextSchema = import_v42.z.object({
+  models: import_v42.z.record(import_v42.z.string(), import_v42.z.array(import_v42.z.string()))
+  // { modelHandle: [fieldHandles] }
+});
+var SkillYAMLSchema = import_v42.z.object({
+  // Schema version
+  $schema: import_v42.z.string().optional(),
+  // Identity
+  handle: import_v42.z.string(),
+  name: import_v42.z.string(),
+  version: import_v42.z.string().optional(),
+  description: import_v42.z.string().optional(),
+  // Instructions injected into agent system prompt
+  instructions: import_v42.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: import_v42.z.array(SkillExampleSchema).optional(),
+  // Evaluation criteria
+  evaluation: import_v42.z.array(SkillEvaluationMetricSchema).optional(),
+  // Tags for discovery
+  tags: import_v42.z.array(import_v42.z.string()).optional()
+});
+var SkillYAMLV2Schema = import_v42.z.object({
+  $schema: import_v42.z.literal(SKILL_SCHEMA_VERSION_V2).optional(),
+  handle: import_v42.z.string(),
+  name: import_v42.z.string(),
+  version: import_v42.z.string().optional(),
+  description: import_v42.z.string().optional(),
+  instructions: import_v42.z.string(),
+  tools: import_v42.z.array(SkillToolDefinitionSchema).optional(),
+  crmContext: CRMContextSchema.optional(),
+  examples: import_v42.z.array(SkillExampleSchema).optional(),
+  evaluation: import_v42.z.array(SkillEvaluationMetricSchema).optional(),
+  tags: import_v42.z.array(import_v42.z.string()).optional()
+});
+var SkillVersionWeightSchema = import_v42.z.object({
+  version: import_v42.z.number(),
+  weight: import_v42.z.number()
+});
+var SkillRefSchema = import_v42.z.union([
+  import_v42.z.string(),
+  // Just handle - uses latest published version
+  import_v42.z.object({
+    skill: import_v42.z.string(),
+    description: import_v42.z.string().optional(),
+    // For AI SDK Agent Skills discovery
+    // Version selection (pick one):
+    version: import_v42.z.number().optional(),
+    // Pin to specific version number
+    versions: import_v42.z.array(SkillVersionWeightSchema).optional(),
+    // A/B testing weights
+    // Legacy support:
+    instructions: import_v42.z.string().optional(),
+    // Inline instructions (deprecated)
+    enabled: import_v42.z.boolean().optional()
+  })
+]);
+var SkillMetadataSchema = import_v42.z.object({
+  id: import_v42.z.string(),
+  handle: import_v42.z.string(),
+  name: import_v42.z.string(),
+  version: import_v42.z.string().optional(),
+  description: import_v42.z.string().optional(),
+  source: SkillSourceSchema,
+  s3Key: import_v42.z.string().optional(),
+  appVersionId: import_v42.z.string().optional(),
+  workplaceId: import_v42.z.string().optional(),
+  tags: import_v42.z.array(import_v42.z.string()).optional(),
+  createdAt: import_v42.z.string().datetime().optional(),
+  updatedAt: import_v42.z.string().datetime().optional()
+});
+var ResolvedSkillSchema = import_v42.z.object({
+  handle: import_v42.z.string(),
+  name: import_v42.z.string(),
+  instructions: import_v42.z.string().optional(),
+  description: import_v42.z.string().optional(),
+  tools: import_v42.z.array(import_v42.z.string()).optional(),
+  examples: import_v42.z.array(SkillExampleSchema).optional()
+});
+var LoadedSkillSchema = import_v42.z.object({
+  handle: import_v42.z.string(),
+  name: import_v42.z.string(),
+  instructions: import_v42.z.string().optional(),
+  description: import_v42.z.string().optional(),
+  tools: import_v42.z.array(SkillToolDefinitionSchema).optional(),
+  examples: import_v42.z.array(SkillExampleSchema).optional()
+});
+
+// src/context/types.ts
+var import_v43 = require("zod/v4");
+var CRMContextSchema2 = import_v43.z.object({
+  model: import_v43.z.string(),
+  instanceId: import_v43.z.string(),
+  data: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown())
+});
+var SenderContextSchema = import_v43.z.object({
+  kind: ParticipantKindSchema,
+  displayName: import_v43.z.string().optional(),
+  email: import_v43.z.string().optional(),
+  role: import_v43.z.string().optional(),
+  permissions: import_v43.z.array(import_v43.z.string()).optional(),
+  crm: CRMContextSchema2.optional()
+});
+var ThreadContextItemSchema = import_v43.z.object({
+  handle: import_v43.z.string(),
+  model: import_v43.z.string(),
+  instanceId: import_v43.z.string(),
+  data: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).optional()
+});
+var ThreadInfoSchema = import_v43.z.object({
+  id: import_v43.z.string(),
+  title: import_v43.z.string().optional(),
+  status: import_v43.z.string().optional(),
+  kind: import_v43.z.string().optional()
+});
+var AgentContextSchema = import_v43.z.object({
+  // Who sent the message
+  sender: SenderContextSchema,
+  // Thread contexts (linked CRM instances)
+  contexts: import_v43.z.array(ThreadContextItemSchema).optional(),
+  // Thread info
+  thread: ThreadInfoSchema,
+  // Workplace info
+  workplace: import_v43.z.object({
+    id: import_v43.z.string(),
+    name: import_v43.z.string().optional()
+  }).optional()
+});
+var MockSubscriptionSchema = import_v43.z.object({
+  identifierValue: import_v43.z.string(),
+  channelHandle: import_v43.z.string().optional()
+});
+var MockAssociationSchema = import_v43.z.object({
+  id: import_v43.z.string().optional(),
+  data: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown())
+});
+var MockContactSchema = import_v43.z.object({
+  id: import_v43.z.string().optional(),
+  name: import_v43.z.string().optional(),
+  subscription: MockSubscriptionSchema.optional(),
+  associations: import_v43.z.record(import_v43.z.string(), MockAssociationSchema).optional()
+});
+var MockSenderContextSchema = import_v43.z.object({
+  kind: import_v43.z.enum(["contact", "member"]),
+  displayName: import_v43.z.string().optional(),
+  role: import_v43.z.string().optional(),
+  permissions: import_v43.z.array(import_v43.z.string()).optional(),
+  contact: MockContactSchema.optional()
+});
+var MockThreadContextSchema = import_v43.z.object({
+  handle: import_v43.z.string(),
+  model: import_v43.z.string(),
+  data: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown())
+});
+var MockContextSchema = import_v43.z.object({
+  sender: MockSenderContextSchema,
+  contexts: import_v43.z.array(MockThreadContextSchema).optional()
+});
+var SandboxConfigSchema = import_v43.z.object({
+  enabled: import_v43.z.boolean().optional(),
+  mockContext: MockContextSchema.optional()
+});
+
+// src/schemas/agent-schema-v3.ts
+var AGENT_SCHEMA_VERSION_V3 = "https://skedyul.com/schemas/agent/v3";
+var PersonaVoiceFormatV3Schema = import_v44.z.object({
+  maxChars: import_v44.z.number().optional(),
+  noEmojis: import_v44.z.boolean().optional(),
+  noHyphens: import_v44.z.boolean().optional(),
+  noBulletPoints: import_v44.z.boolean().optional(),
+  maxQuestionsPerMessage: import_v44.z.number().optional(),
+  noSignOffs: import_v44.z.boolean().optional()
+});
+var PersonaVoiceV3Schema = import_v44.z.object({
+  style: import_v44.z.string(),
+  format: PersonaVoiceFormatV3Schema.optional()
+});
+var PersonaV3Schema = import_v44.z.object({
+  name: import_v44.z.string(),
+  voice: PersonaVoiceV3Schema
+});
+var ToolApprovalConfigSchema = import_v44.z.object({
+  required: import_v44.z.boolean().optional(),
+  requiredIf: import_v44.z.array(import_v44.z.string()).optional()
+});
+var ToolSandboxConfigSchema = import_v44.z.object({
+  mock: import_v44.z.unknown().optional()
+});
+var ToolRefV3Schema = import_v44.z.union([
+  import_v44.z.string(),
+  import_v44.z.object({
+    tool: import_v44.z.string(),
+    description: import_v44.z.string().optional(),
+    approval: ToolApprovalConfigSchema.optional(),
+    sandbox: ToolSandboxConfigSchema.optional(),
+    overrides: import_v44.z.record(import_v44.z.string(), import_v44.z.unknown()).optional()
+  })
+]);
+var BootstrapToolRefSchema = import_v44.z.union([
+  import_v44.z.string(),
+  import_v44.z.object({
+    tool: import_v44.z.string(),
+    description: import_v44.z.string().optional()
+  })
+]);
+var WorkingMemoryConfigSchema = import_v44.z.object({
+  strategy: import_v44.z.enum(["full", "rolling_summary", "sliding_window"]).optional(),
+  maxTokens: import_v44.z.number().optional(),
+  summarizeAt: import_v44.z.number().optional()
+});
+var ExternalMemoryConfigSchema = import_v44.z.object({
+  enabled: import_v44.z.boolean().optional(),
+  ttl: import_v44.z.string().optional()
+});
+var SemanticMemoryConfigSchema = import_v44.z.object({
+  enabled: import_v44.z.boolean().optional(),
+  topK: import_v44.z.number().optional(),
+  scope: import_v44.z.enum(["thread", "instance", "workspace"]).optional()
+});
+var MemoryConfigV3Schema = import_v44.z.object({
+  working: WorkingMemoryConfigSchema.optional(),
+  persistent: import_v44.z.object({
+    namespace: import_v44.z.string().optional()
+  }).optional(),
+  external: ExternalMemoryConfigSchema.optional(),
+  semantic: SemanticMemoryConfigSchema.optional()
+});
+var ResponsePolicySchema = import_v44.z.object({
+  requiresApproval: import_v44.z.boolean().optional(),
+  requiresApprovalIf: import_v44.z.array(import_v44.z.string()).optional()
+});
+var PoliciesConfigV3Schema = import_v44.z.object({
+  response: ResponsePolicySchema.optional(),
+  rules: import_v44.z.array(import_v44.z.string()).optional()
+});
+var RuntimeConfigV3Schema = import_v44.z.object({
+  model: import_v44.z.string().optional(),
+  timeout: import_v44.z.string().optional(),
+  timezone: import_v44.z.string().optional(),
+  retry: import_v44.z.object({
+    attempts: import_v44.z.number().optional(),
+    backoff: import_v44.z.enum(["linear", "exponential"]).optional()
+  }).optional()
+});
+var PromptsConfigV3Schema = import_v44.z.object({
+  recovery: import_v44.z.string().optional(),
+  followUp: import_v44.z.string().optional(),
+  skillDiscoveryWorkflow: import_v44.z.string().optional()
+});
+var AgentConfigV3Schema = import_v44.z.record(import_v44.z.string(), import_v44.z.unknown());
+var AgentYAMLV3Schema = import_v44.z.object({
+  $schema: import_v44.z.string().optional(),
+  handle: import_v44.z.string(),
+  name: import_v44.z.string(),
+  version: import_v44.z.string().optional(),
+  description: import_v44.z.string().optional(),
+  // Persona - Who the agent is
+  persona: PersonaV3Schema.optional(),
+  // Skills - What the agent knows how to do (skills own their tools)
+  skills: import_v44.z.array(SkillRefSchema).optional(),
+  // Bootstrap tools - Always-available system tools before any skill loads
+  // Examples: system:skill:load, system:message:send
+  bootstrapTools: import_v44.z.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: import_v44.z.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 };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_SCHEMA_VERSION_V3,
+  AgentConfigV3Schema,
+  AgentYAMLV3Schema,
+  BootstrapToolRefSchema,
+  ExternalMemoryConfigSchema,
+  MemoryConfigV3Schema,
+  PersonaV3Schema,
+  PersonaVoiceFormatV3Schema,
+  PersonaVoiceV3Schema,
+  PoliciesConfigV3Schema,
+  PromptsConfigV3Schema,
+  ResponsePolicySchema,
+  RuntimeConfigV3Schema,
+  SemanticMemoryConfigSchema,
+  ToolApprovalConfigSchema,
+  ToolRefV3Schema,
+  ToolSandboxConfigSchema,
+  WorkingMemoryConfigSchema,
+  defineAgentV3,
+  validateAgentYAMLV3
+});