@scout9/app 1.0.0-alpha.0.5.8 → 1.0.0-alpha.0.6.0

package/src/public.d.ts

@@ -359,6 +359,12 @@ export type Agent = {
     model?: ("Scout9" | "bard" | "openai");
     transcripts?: Message[][] | undefined;
     audios?: any[] | undefined;
+    pmt?: {
+        tag?: string;
+        ingress: "auto" | "manual" | "app" | "webhook";
+        llm?: string;
+        scout9?: string;
+    }
 };
 
 export type AgentConfiguration = Agent & {id: string};
@@ -537,6 +543,14 @@ export type IntentWorkflowEvent = {
     initial: string | null;
 };
 
+export type MessageEntity = {
+    start: number;
+    end: number;
+    type: string;
+    option?: string | null;
+    text?: string | null;
+}
+
 export type Message = {
     /** Unique ID for the message */
     id: string;
@@ -555,6 +569,8 @@ export type Message = {
     intentScore?: (number | null) | undefined;
     /** How long to delay the message manually in seconds */
     delayInSeconds?: (number | null) | undefined;
+    /** Entities related to the message */
+    entities?: MessageEntity[] | null;
 };
 
 export type PersonaConfiguration = AgentConfiguration;
@@ -630,7 +646,7 @@ export type WorkflowEvent = {
     conversation: Conversation;
     context?: any;
     message: Message;
-    agent: Omit<AgentConfiguration, 'transcripts' | 'audios' | 'includedLocations' | 'excludedLocations' | 'model' | 'context'>;
+    agent: Omit<AgentConfiguration, 'transcripts' | 'audios' | 'includedLocations' | 'excludedLocations' | 'model' | 'context' | 'pmt'>;
     customer: Customer;
     intent: IntentWorkflowEvent;
     stagnationCount: number;
@@ -657,7 +673,7 @@ export type WorkflowResponseSlotBase = {
     forwardNote?: string | undefined;
     instructions?: Instruction[] | undefined;
     removeInstructions?: string[] | undefined;
-    message?: string | undefined;
+    message?: string | {content: string; transform?: boolean} | undefined;
     secondsDelay?: number | undefined;
     scheduled?: number | undefined;
     contextUpsert?: {
@@ -698,7 +714,6 @@ export type WorkflowResponseMessageApiResponse = string | {
     };
 };
 
-
 export type WorkflowsConfiguration = {
     /** Workflow id association, used to handle route params */
     entities: string[];

package/src/runtime/schemas/message.js

@@ -1,6 +1,14 @@
 import { z } from 'zod';
 import { zId } from './utils.js';
 
+export const MessageEntitySchema = z.object({
+  start: z.number(),
+  end: z.number(),
+  type: z.string(),
+  option: z.string().optional().nullable(),
+  text: z.string().optional().nullable()
+});
+
 export const MessageSchema = z.object({
   id: zId('Message ID', {description: 'Unique ID for the message'}),
   role: z.enum(['agent', 'customer', 'system']),
@@ -11,5 +19,6 @@ export const MessageSchema = z.object({
   context: z.any({description: 'The context generated from the message'}).optional(),
   intent: z.string({description: 'Detected intent'}).optional().nullable(),
   intentScore: z.number({description: 'Confidence score of the assigned intent'}).nullable().optional(),
-  delayInSeconds: z.number({description: 'How long to delay the message manually in seconds'}).nullable().optional()
+  delayInSeconds: z.number({description: 'How long to delay the message manually in seconds'}).nullable().optional(),
+  entities: z.array(MessageEntitySchema).optional().nullable()
 });

package/src/runtime/schemas/users.js

@@ -45,7 +45,15 @@ export const AgentSchema = z.object({
   excludedLocations: z.array(z.string({description: 'Locations the agent is excluded from'})).optional(),
   model: z.enum(['Scout9', 'bard', 'openai']).optional().default('openai'),
   transcripts: z.array(z.array(MessageSchema)).optional(),
-  audios: z.array(z.any()).optional()
+  audios: z.array(z.any()).optional(),
+  pmt: z.object({
+    tag: z.string().optional(),
+    ingress: z.enum(["auto", "manual", "app", "workflow"]),
+    llm: z.string().optional(),
+    webhookUri: z.string().optional(),
+    watermarkEnabled: z.boolean().optional(),
+    watermark: z.string().optional()
+  }).optional()
 });
 
 export const PersonaSchema = AgentSchema;

package/src/runtime/schemas/workflow.js

@@ -134,7 +134,8 @@ export const WorkflowEventSchema = z.object({
     includedLocations: true,
     excludedLocations: true,
     model: true,
-    context: true
+    context: true,
+    pmt: true
   }),
   customer: CustomerSchema,
   intent: IntentWorkflowEventSchema,
@@ -151,7 +152,10 @@ export const WorkflowResponseSlotBaseSchema = z.object({
     .optional(),
   instructions: InstructionSchema.optional(),
   removeInstructions: z.array(z.string()).optional(),
-  message: z.string().optional(),
+  message: z.union([z.string(), z.object({
+    content: z.string(),
+    transform: z.boolean().optional()
+  })]).optional(),
   secondsDelay: z.number().optional(),
   scheduled: z.number().optional(),
   contextUpsert: ConversationContext.optional(),

package/src/testing-tools/spirits.js

@@ -19,6 +19,7 @@
  * @property {Array<import('@scout9/app').Message>} messages
  * @property {import('@scout9/app').Message} message - the message sent by the customer (should exist in messages)
  * @property {import('@scout9/app').Customer} customer
+ * @property {import('@scout9/app').ConversationProgress} progress - progress checklist for manual/auto ingress workflows (needed if conversation progress is not managed by external webhooks or @scout9 apps (ingress app/webhook)
  * @property {any} context
  */
 
@@ -46,6 +47,14 @@
  * @property {any} context
  */
 
+/**
+ * @typedef {Object} GenerateOutput
+ * @property {import('@scout9/admin').GenerateResponse | undefined} generate
+ * @property {Array<import('@scout9/app').Message>} messages
+ * @property {import('@scout9/app').Conversation} conversation
+ * @property {any} context
+ */
+
 /**
  * @callback ParseFun
  * @param {string} message - message to send
@@ -65,11 +74,18 @@
  * @returns {Promise<import('@scout9/admin').GenerateResponse>}
  */
 
+/**
+ * @callback TransformerFun
+ * @param {import('@scout9/admin').PmtTransformRequest} data - data to generate from
+ * @returns {Promise<import('@scout9/admin').PmtTransformResponse>}
+ */
+
 /**
  * @callback IdGeneratorFun
  * @param {import('@scout9/app').Message['role']} prefix
  * @returns {string}
  */
+
 /**
  * @callback StatusCallback
  * @param {string} message
@@ -84,6 +100,7 @@
  * @property {ParseFun} parser
  * @property {WorkflowFun} workflow
  * @property {GenerateFun} generator
+ * @property {TransformerFun} transformer
  * @property {IdGeneratorFun} idGenerator
  * @property {StatusCallback | undefined} [progress]
  */
@@ -110,6 +127,7 @@ export const Spirits = {
       parser,
       workflow,
       generator,
+      transformer,
       idGenerator,
       progress = (message, level, type, payload) => {
       },
@@ -265,6 +283,7 @@ export const Spirits = {
       message.intentScore = parsePayload.intentScore;
     }
     message.context = parsePayload.context;
+    message.entities = parsePayload.entities;
     const index = messages.findIndex(m => m.content === message.content || m.id === message.id);
     if (index === -1) {
       const _message = {
@@ -272,6 +291,7 @@ export const Spirits = {
         role: 'customer',
         content: message,
         context: parsePayload.context,
+        entities: parsePayload.entities,
         time: new Date().toISOString()
       };
       if (parsePayload.intent) {
@@ -285,6 +305,7 @@ export const Spirits = {
       progress('Added message', 'info', 'ADD_MESSAGE', _message);
     } else {
       messages[index].context = parsePayload.context;
+      messages[index].entities = parsePayload.entities;
       if (parsePayload.intent) {
         messages[index].intent = parsePayload.intent;
       }
@@ -349,6 +370,7 @@ export const Spirits = {
       }, []));
     const hasNoInstructions = slots.every(s => !s.instructions || (Array.isArray(s.instructions) && s.instructions.length === 0));
     const hasNoCustomMessage = slots.every(s => !s.message);
+    const messagesToTransform = slots.filter(s => !!s.message && typeof s.message === 'object' && !!s.message.transform);
     const previousLockAttempt = conversation.lockAttempts || 0; // Used to track
 
     if (hasNoInstructions && noNewContext) {
@@ -596,6 +618,43 @@ export const Spirits = {
           conversation = lockConversation(conversation, 'API: ' + e.message);
         }
       }
+
+      if (messagesToTransform.length && transformer) {
+        try {
+          for (const messageToTransform of messagesToTransform) {
+            const transformResponse = await transformer({
+              message: messagesToTransform,
+              persona,
+              customer: customer.id,
+              messages,
+              context: context
+            });
+
+            progress('Generated response', 'success', undefined, undefined);
+            // Check if already had message
+            const agentMessages = messages.filter(m => m.role === 'agent');
+            const lastAgentMessage = agentMessages[agentMessages.length - 1];
+            if (lastAgentMessage && lastAgentMessage.content === transformResponse.message) {
+              // Error should not have happened
+              conversation = lockConversation(conversation, 'Duplicate message');
+            } else {
+              messages.push({
+                id: idGenerator('agent'),
+                role: 'agent',
+                content: transformResponse.message,
+                time: new Date().toISOString()
+              });
+              progress('Added agent message', 'info', 'ADD_MESSAGE', messages[messages.length - 1]);
+            }
+
+          }
+        } catch (e) {
+          console.error(`Locking conversation, error transforming response: ${e.message}`);
+          conversation = lockConversation(conversation, 'API: ' + e.message);
+        }
+      } else if (messagesToTransform.length) {
+        console.warn(`No transformer provided`)
+      }
     }
 
     progress('Parsing message', 'info', 'SET_PROCESSING', null);