@scout9/app 1.0.0-alpha.0.5.3 → 1.0.0-alpha.0.5.4

package/src/core/config/agents.js

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import colors from 'kleur';
 import { globSync } from 'glob';
 import { Configuration, Scout9Api } from '@scout9/admin';
-import { checkVariableType, requireProjectFile } from '../../utils/index.js';
+import { checkVariableType, requireProjectFile, simplifyError } from '../../utils/index.js';
 import { AgentsSchema, AgentsConfigurationSchema } from '../../runtime/index.js';
 import { audioExtensions } from '../../utils/audio-type.js';
 import { fileTypeFromBuffer } from '../../utils/file-type.js';
@@ -315,8 +315,7 @@ export default async function loadAgentConfig({
 
   const result = (deploying ? AgentsConfigurationSchema : AgentsSchema).safeParse(agents);
   if (!result.success) {
-    result.error.source = paths[0];
-    throw result.error;
+    throw simplifyError(result.error);
   }
 
   if (serverDeployed) {

package/src/core/config/commands.js

@@ -1,41 +1,51 @@
 import { globSync } from 'glob';
-import { CommandsSchema } from '../../runtime/index.js';
+import { CommandSchema, CommandsSchema } from '../../runtime/index.js';
 import { basename, dirname } from 'node:path';
+import { simplifyError } from '../../utils/index.js';
+import { logUserValidationError } from '../../report.js';
 
 
 /**
  * @returns {Promise<CommandConfiguration[]>}
  */
 export default async function loadCommandsConfig(
-  {
-    cwd = process.cwd(),
-    src = 'src',
-    cb = (message) => {}
-  } = {}
+    {
+        cwd = process.cwd(),
+        src = 'src',
+        cb = (message) => {
+        }
+    } = {}
 ) {
-  // const config = globSync(path.resolve(cwd, `${src}/workflows/**/workflow.{ts,js}`), {cwd, absolute: true})
-  const config = globSync(`${src}/commands/**/{index,command,*.command}.{ts,js}`, {cwd, absolute: false})
-    .map((path) => {
+    // const config = globSync(path.resolve(cwd, `${src}/workflows/**/workflow.{ts,js}`), {cwd, absolute: true})
+    const config = globSync(`${src}/commands/**/{index,command,*.command}.{ts,js}`, {cwd, absolute: false})
+        .map((path) => {
 
-      const dir = dirname(path);
-      let entity = basename(path).replace(/\..*$/, ''); // Removes any "."'s
-      if (!entity) {
-        throw new Error(`Invalid command path "${path}"`)
-      }
-      switch (entity) {
-        case "index":
-        case "command":
-          entity = basename(dir);
-          break;
-      }
-      return {
-        entity,
-        path: path.split(src + '/commands/')[1],
-      }
-    });
+            const dir = dirname(path);
+            let entity = basename(path).replace(/\..*$/, ''); // Removes any "."'s
+            if (!entity) {
+                throw new Error(`Invalid command path "${path}"`);
+            }
+            switch (entity) {
+                case 'index':
+                case 'command':
+                    entity = basename(dir);
+                    break;
+            }
+            try {
+                return CommandSchema.parse({
+                    entity,
+                    path: path.split(src + '/commands/')[1]
+                });
+            } catch (e) {
+                throw logUserValidationError(e, path);
+            }
+        });
 
-  // Validate the config
-  CommandsSchema.parse(config);
+    // Validate the config
+    try {
+        return CommandsSchema.parse(config);
+    } catch (e) {
+        throw simplifyError(e);
+    }
 
-  return config;
 }

package/src/core/config/entities.js

@@ -6,7 +6,7 @@ import {
     EntityConfigurationSchema,
     EntityRootProjectConfigurationSchema
 } from '../../runtime/index.js';
-import { checkVariableType, requireOptionalProjectFile, requireProjectFile } from '../../utils/index.js';
+import { checkVariableType, requireOptionalProjectFile, requireProjectFile, simplifyError } from '../../utils/index.js';
 import { logUserValidationError } from '../../report.js';
 
 async function loadEntityApiConfig(cwd, filePath) {
@@ -23,8 +23,11 @@ async function loadEntityApiConfig(cwd, filePath) {
         config[key] = true;
       }
     }
-    EntityApiConfigurationSchema.parse(config);
-    return config;
+    try {
+      return EntityApiConfigurationSchema.parse(config);
+    } catch (e) {
+      throw simplifyError(config);
+    }
   } else {
     return null;
   }
@@ -81,8 +84,7 @@ export default async function loadEntitiesConfig(
       // Validate entity configuration
       const result = EntityConfigurationSchema.safeParse(entityConfig, {path: ['entities', config.length]});
       if (!result.success) {
-        logUserValidationError(result.error, filePath);
-        throw result.error;
+        throw logUserValidationError(result.error, filePath);
       }
     } else if (isSpecial && (fileName === 'index' || fileName === 'config')) {
       // If this is a special entity file, then ignore as we will capture it another method
@@ -96,7 +98,11 @@ export default async function loadEntitiesConfig(
       entities: parents.reverse(),
       api
     };
-    EntityRootProjectConfigurationSchema.parse(entityProjectConfig);
+    try {
+      EntityRootProjectConfigurationSchema.parse(entityProjectConfig);
+    } catch (e) {
+      throw simplifyError(e);
+    }
     const existingIndex = config.findIndex(c => c.entity === entityProjectConfig.entity);
     if (existingIndex > -1) {
       if (config[existingIndex].entities.length !== entityProjectConfig.entities.length) {
@@ -134,8 +140,10 @@ export default async function loadEntitiesConfig(
   }
 
   // Validate the config
-  EntitiesRootProjectConfigurationSchema.parse(config);
-
-  return config;
+  try {
+    return EntitiesRootProjectConfigurationSchema.parse(config);
+  } catch (e) {
+    throw simplifyError(e);
+  }
 }
 

package/src/core/config/index.js

@@ -6,8 +6,9 @@ import loadEntitiesConfig from './entities.js';
 import loadProjectConfig from './project.js';
 import loadWorkflowsConfig from './workflow.js';
 import { Scout9ProjectBuildConfigSchema } from '../../runtime/index.js';
-import { ProgressLogger } from '../../utils/index.js';
+import { ProgressLogger, simplifyError } from '../../utils/index.js';
 import loadCommandsConfig from './commands.js';
+import { logUserValidationError } from '../../report.js';
 
 
 export function loadEnvConfig({
@@ -65,7 +66,7 @@ export async function loadConfig({
   const result = Scout9ProjectBuildConfigSchema.safeParse(projectConfig);
   if (!result.success) {
     result.error.source = `${src}/index.js`;
-    throw result.error;
+    throw logUserValidationError(result.error, `${src}/index.js`);
   }
 
   return projectConfig;

package/src/core/config/workflow.js

@@ -1,5 +1,6 @@
 import { globSync } from 'glob';
 import { WorkflowConfigurationSchema, WorkflowsConfigurationSchema } from '../../runtime/index.js';
+import { logUserValidationError } from '../../report.js';
 
 
 /**
@@ -35,13 +36,18 @@ export default async function loadWorkflowsConfig(
         entity: parents[0],
         entities: parents.reverse(),
       }
-      WorkflowConfigurationSchema.parse(workflowConfig);
-
-      return workflowConfig;
+      try {
+        return WorkflowConfigurationSchema.parse(workflowConfig);
+      } catch (e) {
+        throw logUserValidationError(e, path);
+      }
     });
 
   // Validate the config
-  WorkflowsConfigurationSchema.parse(config);
+  try {
+    return WorkflowsConfigurationSchema.parse(config);
+  } catch (e) {
+    throw logUserValidationError(e, src);
+  }
 
-  return config;
 }

package/src/core/index.js

@@ -6,7 +6,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import fetch, { FormData } from 'node-fetch';
 import { Configuration, Scout9Api } from '@scout9/admin';
-import { checkVariableType, ProgressLogger, requireProjectFile } from '../utils/index.js';
+import { checkVariableType, ProgressLogger, requireProjectFile, simplifyError } from '../utils/index.js';
 import decompress from 'decompress';
 import { loadUserPackageJson } from './config/project.js';
 import { platformApi } from './data.js';
@@ -300,8 +300,7 @@ export async function getAgentContacts() {
 export async function run(event, {eventSource} = {}) {
   const result = WorkflowEventSchema.safeParse(event);
   if (!result.success) {
-    logUserValidationError(result.error, eventSource);
-    throw result.error;
+    throw logUserValidationError(result.error, eventSource);
   }
   const configuration = new Configuration({
     apiKey: process.env.SCOUT9_API_KEY

package/src/report.js

@@ -1,16 +1,17 @@
 import { red, cyan, green, dim, white, grey, bold, italic, magenta, yellow } from 'kleur/colors';
-import { ProgressLogger } from './utils/index.js';
+import { ProgressLogger, simplifyError } from './utils/index.js';
 
 /**
  *
  * @param {import('zod').ZodError} zodError
  * @param {string} source
+ * @returns {import('zod-validation-error').ValidationError}
  */
 export function logUserValidationError(
   zodError,
   source,
 ) {
-  const issues = zodError.issues || [];
+  const issues = zodError?.issues || [];
 
   console.log(red(`Scout9 Schema Validation Error at ${bold(source)}, fix these issues and rerun`));
   for (const {code, expected, received, path, message} of issues) {
@@ -29,6 +30,11 @@ export function logUserValidationError(
     }
     console.log('\t', objectPath, grey(`${text}`));
   }
+
+  const simplifiedError = simplifyError(zodError);
+  console.error(`\n${red(simplifiedError.message)}\n`);
+
+  return simplifiedError;
 }
 
 

package/src/runtime/schemas/conversation.js

@@ -1,47 +1,52 @@
 import { z } from 'zod';
 import { zId } from './utils.js';
+import { CommandsSchema } from './workflow.js';
 
 export const ConversationContext = z.record(
-  z.union([
-    z.any(),
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(
-      z.union([z.string(), z.number(), z.boolean(), z.null()])
-    )
-  ])
+    z.union([
+        z.any(),
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.null(),
+        z.array(
+            z.union([z.string(), z.number(), z.boolean(), z.null()])
+        )
+    ])
 );
 
 export const ConversationAnticipateSchema = z.object({
-  type: z.enum(['did', 'literal', 'context'], {description: "Determines the runtime to address the next response"}),
-  slots: z.record(z.string(), z.array(z.any())),
-  did: z.string({description: 'For type \'did\''}).optional(),
-  map: z.array(z.object({
-    slot: z.string(),
-    keywords: z.array(z.string())
-  }), {description: 'For literal keywords, this map helps point which slot the keyword matches to'}).optional()
+    type: z.enum(['did', 'literal', 'context'], {description: 'Determines the runtime to address the next response'}),
+    slots: z.record(z.string(), z.array(z.any())),
+    did: z.string({description: 'For type \'did\''}).optional(),
+    map: z.array(z.object({
+        slot: z.string(),
+        keywords: z.array(z.string())
+    }), {description: 'For literal keywords, this map helps point which slot the keyword matches to'}).optional()
 });
 
 export const ConversationSchema = z.object({
-  $id: zId('Conversation ID', z.string({description: 'Conversation unique id'})),
-  $agent: zId('Conversation Agent ID', z.string({description: 'Default agent assigned to the conversation(s)'})),
-  $customer: zId('Conversation Customer ID', z.string({description: 'Customer this conversation is with'})),
-  initialContexts: z.array(z.string(), {description: 'Initial contexts to load when starting the conversation'})
-    .optional(),
-  environment: z.enum(['phone', 'email', 'web']),
-  environmentProps: z.object({
-    subject: z.string({description: 'HTML Subject of the conversation'}).optional(),
-    platformEmailThreadId: z.string({description: 'Used to sync email messages with the conversation'}).optional()
-  }).optional(),
-  locked: z.boolean({description: 'Whether the conversation is locked or not'}).optional().nullable(),
-  lockedReason: z.string({description: 'Why this conversation was locked'}).optional().nullable(),
-  lockAttempts: z.number({description: 'Number attempts made until conversation is locked'}).optional().nullable(),
-  forwardedTo: z.string({description: 'What personaId/phone/email was forwarded'}).optional().nullable(),
-  forwarded: z.string({description: 'Datetime ISO 8601 timestamp when persona was forwarded'}).optional().nullable(),
-  forwardNote: z.string().optional().nullable(),
-  intent: z.string({description: 'Detected intent of conversation'}).optional().nullable(),
-  intentScore: z.number({description: 'Confidence score of the assigned intent'}).optional().nullable(),
-  anticipate: ConversationAnticipateSchema.optional()
+    $id: zId('Conversation ID', z.string({description: 'Conversation unique id'})),
+    $agent: zId('Conversation Agent ID', z.string({description: 'Default agent assigned to the conversation(s)'})),
+    $customer: zId('Conversation Customer ID', z.string({description: 'Customer this conversation is with'})),
+    initialContexts: z.array(z.string(), {description: 'Initial contexts to load when starting the conversation'})
+        .optional(),
+    environment: z.enum(['phone', 'email', 'web']),
+    environmentProps: z.object({
+        subject: z.string({description: 'HTML Subject of the conversation'}).optional(),
+        platformEmailThreadId: z.string({description: 'Used to sync email messages with the conversation'}).optional()
+    }).optional(),
+    locked: z.boolean({description: 'Whether the conversation is locked or not'}).optional().nullable(),
+    lockedReason: z.string({description: 'Why this conversation was locked'}).optional().nullable(),
+    lockAttempts: z.number({description: 'Number attempts made until conversation is locked'}).optional().nullable(),
+    forwardedTo: z.string({description: 'What personaId/phone/email was forwarded'}).optional().nullable(),
+    forwarded: z.string({description: 'Datetime ISO 8601 timestamp when persona was forwarded'}).optional().nullable(),
+    forwardNote: z.string().optional().nullable(),
+    intent: z.string({description: 'Detected intent of conversation'}).optional().nullable(),
+    intentScore: z.number({description: 'Confidence score of the assigned intent'}).optional().nullable(),
+    anticipate: ConversationAnticipateSchema.optional(),
+    /**
+     * Whether this conversation is part of a command flow
+     */
+    command: CommandsSchema.optional()
 });