@scout9/app 1.0.0-alpha.0.5.7 → 1.0.0-alpha.0.5.9

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};
@@ -630,7 +636,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 +663,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?: {

package/src/runtime/macros/event.js

@@ -62,27 +62,11 @@ import MacroGlobals from './globals.js';
  * @property {WorkflowResponseSlotBaseWithKeywords[]} withoutCondition.instruction - Array of slots with keywords.
  */
 
-// export type WorkflowResponseSlotBase = {
-//   /** Forward input information of a conversation */
-//   forward?: Forward | undefined;
-//   /** Note to provide to the agent, recommend using forward object api instead */
-//   forwardNote?: string | undefined;
-//   instructions?: Instruction[] | undefined;
-//   removeInstructions?: string[] | undefined;
-//   message?: string | undefined;
-//   secondsDelay?: number | undefined;
-//   scheduled?: number | undefined;
-//   contextUpsert?: {
-//     [x: string]: any;
-// } | undefined;
-// resetIntent?: boolean | undefined;
-// followup?: Followup | undefined;
-// };
-
 
 /**
  * Event macros to be used inside your scout9 auto reply workflows
  * @typedef {Object} EventMacros
+ * @property {function(string, [ContextExamples]): EventMacros} context
  * @property {function(Record<string, any>): EventMacros} upsert
  * @property {function(string, (Date | string | OptionsFollowup)): EventMacros} followup
  * @property {AnticipateFunction} anticipate
@@ -287,6 +271,13 @@ function EventMacrosFactory() {
       return this;
     },
 
+    /**
+     * Same as the context
+     */
+    // context() {
+    //  @TODO insert context proxy
+    // },
+
     /**
      * If conversation is not stagnant, return instructions to guide next auto reply response, otherwise it will forward the conversation
      * @param {string} instruction

package/src/runtime/schemas/users.js

@@ -45,7 +45,12 @@ 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(),
+  }).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

@@ -65,6 +65,12 @@
  * @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
@@ -84,6 +90,7 @@
  * @property {ParseFun} parser
  * @property {WorkflowFun} workflow
  * @property {GenerateFun} generator
+ * @property {TransformerFun} transformer
  * @property {IdGeneratorFun} idGenerator
  * @property {StatusCallback | undefined} [progress]
  */
@@ -110,6 +117,7 @@ export const Spirits = {
       parser,
       workflow,
       generator,
+      transformer,
       idGenerator,
       progress = (message, level, type, payload) => {
       },
@@ -349,6 +357,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 +605,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);