@scout9/app 1.0.0-alpha.0.1.96 → 1.0.0-alpha.0.1.98

package/src/runtime/client/api.js

@@ -1,5 +1,3 @@
-import { z } from 'zod';
-
 /**
  * Utility runtime class used to guide event output
  * @template T
@@ -58,23 +56,3 @@ export class EventResponse {
 
 }
 
-
-
-const responseInitSchema = z.object({
-  status: z.number().optional(),
-  statusText: z.string().optional(),
-  headers: z.any().optional() // Headers can be complex; adjust as needed
-});
-
-/**
- * @template T
- * @typedef {object} IEventResponse
- * @property {T} body - The body of the response.
- * @property {ResponseInit} [init] - Additional options for the response.
- * @property {Response} response - The response object.
- * @property {T} data - The body of the response.
- */
-export const eventResponseSchema = z.object({
-  body: z.any(), // Adjust as per your actual body structure
-  init: responseInitSchema.optional()
-});

package/src/runtime/client/index.js

@@ -1,8 +1,2 @@
-export * from './users.js';
 export * from './api.js';
-export * from './config.js';
-export * from './entity.js';
-export * from './message.js';
-export * from './workflow.js';
-export * from './platform.js';
 

package/src/runtime/index.js

@@ -1,2 +1,3 @@
 export * from './client/index.js';
 export * from './macros/index.js';
+export * from './schemas/index.js'

package/src/runtime/macros/builder.js

@@ -2,7 +2,7 @@
  * Builder Macros
  * used to build and guide a application logic in relation to the Scout9 conversation state.
  */
-import { Configuration, MacroContextResult, Scout9Api } from '@scout9/admin';
+import { Configuration, Scout9Api } from '@scout9/admin';
 import MacroGlobals from './globals.js';
 
 function handleAxiosResponse(res) {
@@ -20,20 +20,41 @@ function handleAxiosResponse(res) {
  */
 export async function did(prompt) {
   const convoId = MacroGlobals.$convo();
+  if (!convoId) {
+    throw new Error(`Internal: Unable to contextualize did response for "${prompt}"`);
+  }
   const {value} = (await (new Scout9Api(new Configuration({apiKey: process.env.SCOUT9_API_KEY}))).did({prompt, convoId})
     .then(handleAxiosResponse));
   return value;
 }
 
+/**
+ * @typedef {import('@scout9/admin').MacroContextInputExamples} ContextExamples
+ * @typedef {import('@scout9/admin').MacroContextValue} ContextOutput
+ */
 
 /**
  * The `context` macro, similar to the `did` macro, takes a natural statement and checks the entire conversation state and extracts or infers a metadata composition result.
- * @param {string} prompt
- * @param {import('@scout9/admin').CaptureContextRequestExamples} [examples]
- * @return {Promise<import('@scout9/admin').MacroContextValue>}
+ *
+ * @example - inferring what a user requested
+ * const response = await context(`What pizzas did the user want to order?`);
+ * {
+ *   "order": {
+ *     "pizzas": [
+ *       {"size": "small", "toppings": ["cheese"], quantity: 1}
+ *     ]
+ *   }
+ * }
+ *
+ * @param {string} prompt - Prompt to infer a context data set to use in your workflow code.
+ * @param {ContextExamples} [examples] - Examples to the macro to ensure a consistent data structure.
+ * @return {Promise<ContextOutput>}
  */
 export async function context(prompt, examples) {
   const convoId = MacroGlobals.$convo();
+  if (!convoId) {
+    throw new Error(`Internal: Unable to contextualize did response for "${prompt}"`);
+  }
   const {value} = (await (new Scout9Api(new Configuration({apiKey: process.env.SCOUT9_API_KEY}))).captureContext({
     prompt,
     examples,

package/src/runtime/macros/event.js

@@ -1,9 +1,77 @@
-import { WorkflowResponseSlotBaseSchema, WorkflowResponseSlotSchema } from '../client/workflow.js';
+import { WorkflowResponseSlotBaseSchema, WorkflowResponseSlotSchema } from '../schemas/workflow.js';
 import { MacroUtils } from './utils.js';
 
 
+/**
+ * followup macro options
+ * @typedef {Object} OptionsFollowup
+ * @property {Date | string} scheduled
+ * @property {Record<string, any>} [cancelIf]
+ * @property {boolean} [literal]
+ * @property {boolean} [overrideLock]
+ */
 
-function EventMacros() {
+/**
+ * instruct macro options
+ * @typedef {Object} OptionsInstruct
+ * @property {string} [id] - Unique ID for the instruction, this is used to remove the instruction later
+ * @property {boolean} [persist] - if true, the instruction persists the conversation, if false the instruction will only last for 1 auto reply
+ */
+
+/**
+ * reply macro options
+ * @typedef {Object} OptionsReply
+ * @property {Date | string} [scheduled]
+ * @property {number} [delay]
+ */
+
+/**
+ * forward macro options
+ * @typedef {Object} OptionsForward
+ * @property {'after-reply' | 'immediately'} [mode] - sets forward mode, defaults to "immediately". If "after-reply", the forward will be on hold until the customer responds. We recommend using "immediately" for most cases.
+ * @property {string} [to] - another phone or email to forward to instead of owner
+ */
+
+/**
+ *
+ * @return {{followup(string, (Date|string|OptionsFollowup)): EventMacros, toJSON(boolean=): Array<WorkflowResponseSlot>, instruct(string, OptionsFollowup=): EventMacros, forward(string=, OptionsForward=): EventMacros, anticipate((string|Array<WorkflowResponseSlotBase&{keywords: string[]}>), WorkflowResponseSlotBaseSchema, WorkflowResponseSlotBaseSchema): EventMacros, upsert(Record<string, *>): EventMacros, reply(string, OptionsReply=): EventMacros}|*|*[]}
+ * @constructor
+ */
+
+/**
+ * @typedef {WorkflowResponseSlotBase & {keywords: string[]}} WorkflowResponseSlotBaseWithKeywords
+ * - Extends `WorkflowResponseSlotBase` to include keywords.
+ * @property {string[]} keywords - Keywords associated with the slot.
+ */
+
+/**
+ * @typedef {(
+ *   (instruction: string, yes: WorkflowResponseSlotBase, no: WorkflowResponseSlotBase) => EventMacros |
+ *   (instruction: WorkflowResponseSlotBaseWithKeywords[]) => EventMacros
+ * )} AnticipateFunction
+ * - Defines the overloads for the `anticipate` function.
+ * @property {function(string, WorkflowResponseSlotBase, WorkflowResponseSlotBase): EventMacros} withCondition
+ * - Overload for when the instruction is a string.
+ * @property {string} withCondition.instruction - The instruction as a string.
+ * @property {WorkflowResponseSlotBase} withCondition.yes - Object to process if the condition is met.
+ * @property {WorkflowResponseSlotBase} withCondition.no - Object to process if the condition is not met.
+ * @property {function(WorkflowResponseSlotBaseWithKeywords[]): EventMacros} withoutCondition
+ * - Overload for when the instruction is an array.
+ * @property {WorkflowResponseSlotBaseWithKeywords[]} withoutCondition.instruction - Array of slots with keywords.
+ */
+
+/**
+ * Event macros to be used inside your scout9 auto reply workflows
+ * @typedef {Object} EventMacros
+ * @property {function(Record<string, any>): EventMacros} upsert
+ * @property {function(string, (Date | string | OptionsFollowup)): EventMacros} followup
+ * @property {AnticipateFunction} anticipate
+ * @property {function(string, OptionsInstruct?): EventMacros} instruct
+ * @property {function(string, OptionsReply?): EventMacros} reply
+ * @property {function(string?, OptionsForward?): EventMacros} forward
+ * @property {function(boolean?): Array<WorkflowResponseSlot>} toJSON
+ */
+function EventMacrosFactory() {
 
   let slots = [];
 
@@ -12,7 +80,7 @@ function EventMacros() {
     /**
      * Sets context into the conversation context for later use
      * @param {Record<string, any>} updates
-     * @return {this}
+     * @return {EventMacros}
      */
     upsert(updates) {
       const slot = {contextUpsert: updates}
@@ -24,18 +92,9 @@ function EventMacros() {
      * Similar to `instruction` except that it requires a schedule time parameter that determines when to follow up (and is not an event output macro). This will fire another run job with a new insert system context message, if `options.literal` is set to true, it will be an appended agent message prior to running the workflow app.
      *
      * @param {string} instruction
+     * @param {Date | string | OptionsFollowup} options
      *
-     * @overload
-     * @param {Date | string} options
-     *
-     * @overload
-     * @param {Object} options
-     * @param {Date | string} options.scheduled
-     * @param {Record<string, any>} [options.cancelIf]
-     * @param {boolean} [options.literal]
-     * @param {boolean} [options.overrideLock]
-     *
-     * @return {this}
+     * @return {EventMacros}
      */
     followup(instruction, options) {
       let slot;
@@ -88,11 +147,11 @@ function EventMacros() {
      * Similar to `instruct` except that it requires a schedule time parameter that determines when to follow up (and is not an event output macro). This will fire another run job with a new insert system context message, if `options.literal` is set to true, it will be an appended agent message prior to running the workflow app.
      * @overload
      * @param {string} instruction - The instruction to be anticipated as a string. When this is a string, `yes` and `no` must be provided as objects.
-     * @param {object} yes - The object to process if the instruction is a string and the condition is met.
-     * @param {object} no - The object to process if the instruction is a string and the condition is not met.
+     * @param {WorkflowResponseSlotBaseSchema} yes - The object to process if the instruction is a string and the condition is met.
+     * @param {WorkflowResponseSlotBaseSchema} no - The object to process if the instruction is a string and the condition is not met.
      *
      * @overload
-     * @param {(Array<IWorkflowResponseSlotBase & {keywords: string[]}>)} instruction
+     * @param {(Array<WorkflowResponseSlotBase & {keywords: string[]}>)} instruction
      *
      * @return {EventMacros}
      */
@@ -127,11 +186,9 @@ function EventMacros() {
     },
 
     /**
-     *
+     * Return instructions to guide next auto reply response
      * @param {string} instruction
-     * @param {Object} [options]
-     * @param {string} [options.id] - Unique ID for the instruction, this is used to remove the instruction later
-     * @param {string} [options.persist] - if true, the instruction persists the conversation, if false the instruction will only last for 1 auto reply
+     * @param {OptionsFollowup} [options]
      * @return {EventMacros}
      */
     instruct(instruction, options = {}) {
@@ -156,10 +213,8 @@ function EventMacros() {
     /**
      * If a manual message must be sent, you can use the `reply` macro
      * @param {string} message - the message to manually send to the user
-     * @param {Object} [options]
-     * @param {Date | string} [options.scheduled] - this will schedule the date to a specific provided date
-     * @param {string} [options.delay] - delays the message return in seconds
-     * @return {this}
+     * @param {OptionsReply} [options]
+     * @return {EventMacros}
      */
     reply(message, options = {}) {
       const slot = {
@@ -182,20 +237,19 @@ function EventMacros() {
     },
     /**
      * This macro ends the conversation and forwards it the owner of the persona to manually handle the flow. If your app returns undefined or no event, then a default forward is generated.
-     * @param {string} message - the message to forward to owner of persona
-     * @param {Object} [options]
-     * @param {'after-reply' | 'immediately'} [options.mode] - sets forward mode, defaults to "immediately"
-     * @param {string} [options.to] - another phone or email to forward to instead of owner
-     * @return {this}
+     * @param {string} [message] - the message to forward to owner of persona
+     * @param {OptionsForward} [options]
+     * @return {EventMacros}
      */
     forward(message, options = {}) {
       let slot;
+      const defaultForward = 'Conversation forwarded for manual intervention';
       if (options && Object.keys(options).length) {
         slot = {
           forward: {
-            note: message
+            note: message ?? defaultForward
           },
-          forwardNote: message
+          forwardNote: message ?? defaultForward
         }
         if (options.to) {
           slot.forward.to = options.to;
@@ -206,7 +260,7 @@ function EventMacros() {
       } else {
         slot = {
           forward: true,
-          forwardNote: message
+          forwardNote: message ?? defaultForward
         }
       }
       slots.push(WorkflowResponseSlotSchema.parse(slot));
@@ -214,7 +268,7 @@ function EventMacros() {
     },
     /**
      * Returns event payload
-     * @return {Array<IWorkflowResponseSlot>}
+     * @return {Array<WorkflowResponseSlot>}
      */
     toJSON(flush = true) {
       if (flush) {
@@ -228,7 +282,57 @@ function EventMacros() {
   };
 }
 
-const eventMacros = EventMacros();
+const eventMacros = EventMacrosFactory();
+
+/**
+ * Return instructions to guide next auto reply response
+ * @param {string} instruction - the instruction to send to the
+ * @param {OptionsInstruct} [options]
+ * @return {EventMacros}
+ *
+ * @example instruct("Ask user if they are looking to order a pizza");
+ *
+ * @type {(message: string, options?: OptionsInstruct) => EventMacros}
+ */
 export const instruct = eventMacros.instruct.bind(eventMacros);
+
+/**
+ * Forwards conversation back to you or owner of workflow.
+ *
+ * Typically used when the conversation is over or user is stuck in the workflow and needs manual intervention.
+ *
+ * The provided message input gets sent to you in a sms text with some information why conversation was forwarded.
+ *
+ * Calling this method will lock the conversation and prevent auto replies from being sent to the user.
+ *
+ * @example - end of workflow
+ * forward("User wants 1 cheese pizza ready for pick");
+ *
+ * @example - broken step in workflow
+ * forward("Cannot determine what the user wants");
+ *
+ * @example - forward if user sends a message
+ * reply("Let me know if you're looking for a gutter cleaning").forward("User responded to gutter cleaning request", {mode: 'after-reply'});
+ *
+ * @type {(message: string, options?: OptionsForward) => EventMacros}
+ */
 export const forward = eventMacros.forward.bind(eventMacros);
+
+/**
+ * Manual message to send to the customer from the workflow.
+ *
+ * Typically used to return specific information to the user
+ *
+ * @example - confirming invoice
+ * reply(`So I got...\n${invoiceItems.map((item) => `${}`)}`)
+ * const msg = [
+ *   'So I got...',
+ *   invoice.items.map((item) => `${item.quantity} ${item.name}`),
+ *   `Total: ${invoice.totalStr}`,
+ *   `\nThis look right?`
+ * ].join('\n');
+ * return reply(msg).instruct("If user confirms ask if they prefer to pay cash or credit");
+ *
+ * @type {(message: string, options?: OptionsReply) => EventMacros}
+ */
 export const reply = eventMacros.reply.bind(eventMacros);

package/src/runtime/macros/index.js

@@ -1,3 +1,2 @@
 export * from './event.js';
 export * from './builder.js';
-export * from './schemas.js';

package/src/runtime/schemas/api.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+
+const responseInitSchema = z.object({
+  status: z.number().optional(),
+  statusText: z.string().optional(),
+  headers: z.any().optional() // Headers can be complex; adjust as needed
+});
+
+/**
+ * @template T
+ * @typedef {object} IEventResponse
+ * @property {T} body - The body of the response.
+ * @property {ResponseInit} [init] - Additional options for the response.
+ * @property {Response} response - The response object.
+ * @property {T} data - The body of the response.
+ */
+export const eventResponseSchema = z.object({
+  body: z.any(), // Adjust as per your actual body structure
+  init: responseInitSchema.optional()
+});

package/src/runtime/{client → schemas}/config.js

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-import { agentsBaseConfigurationSchema } from './users.js';
-import { entitiesRootProjectConfigurationSchema } from './entity.js';
+import { AgentsSchema } from './users.js';
+import { EntitiesRootProjectConfigurationSchema } from './entity.js';
 import { WorkflowsConfigurationSchema } from './workflow.js';
 
-const llmModelOptions = z.union([
+const LlmModelOptions = z.union([
   z.literal('gpt-4-1106-preview'),
   z.literal('gpt-4-vision-preview'),
   z.literal('gpt-4'),
@@ -20,22 +20,22 @@ const llmModelOptions = z.union([
   z.string() // for the (string & {}) part
 ]);
 
-const pmtModelOptions = z.union([
+const PmtModelOptions = z.union([
   z.literal('orin-1.0'),
   z.literal('orin-2.0-preview')
 ]);
 
-const llmSchema = z.object({
+const LlmSchema = z.object({
   engine: z.literal('openai'),
-  model: llmModelOptions
+  model: LlmModelOptions
 });
 
-const llamaSchema = z.object({
+const LlamaSchema = z.object({
   engine: z.literal('llama'),
   model: z.string()
 });
 
-const bardSchema = z.object({
+const BardSchema = z.object({
   engine: z.literal('bard'),
   model: z.string()
 });
@@ -43,7 +43,7 @@ const bardSchema = z.object({
 /**
  * Configure personal model transformer (PMT) settings to align auto replies the agent's tone
  */
-const pmtSchema = z.object({
+const PmtSchema = z.object({
   engine: z.literal('scout9'),
   // model: pmtModelOptions
   model: z.string()
@@ -53,7 +53,6 @@ const pmtSchema = z.object({
 
 /**
  * Represents the configuration provided in src/index.{js | ts} in a project
- * @typedef {import('zod').infer<typeof Scout9ProjectConfigSchema>} IScout9ProjectConfig
  */
 export const Scout9ProjectConfigSchema = z.object({
   /**
@@ -61,11 +60,11 @@ export const Scout9ProjectConfigSchema = z.object({
    * @defaut your local package.json name + version, or scout9-app-v1.0.0
    */
   tag: z.string().optional(), // Defaults to scout9-app-v1.0.0
-  llm: z.union([llmSchema, llamaSchema, bardSchema]),
+  llm: z.union([LlmSchema, LlamaSchema, BardSchema]),
   /**
    * Configure personal model transformer (PMT) settings to align auto replies the agent's tone
    */
-  pmt: pmtSchema,
+  pmt: PmtSchema,
 
   /**
    * Determines the max auto replies without further conversation progression (defined by new context data gathered)
@@ -93,12 +92,9 @@ export const Scout9ProjectConfigSchema = z.object({
   }).optional()
 })
 
-/**
- * @typedef {import('zod').infer<typeof Scout9ProjectBuildConfigSchema>} IScout9ProjectBuildConfig
- */
 export const Scout9ProjectBuildConfigSchema = Scout9ProjectConfigSchema.extend({
-  agents: agentsBaseConfigurationSchema,
-  entities: entitiesRootProjectConfigurationSchema,
+  agents: AgentsSchema,
+  entities: EntitiesRootProjectConfigurationSchema,
   workflows: WorkflowsConfigurationSchema
 });
 

package/src/runtime/{client → schemas}/entity.js

@@ -2,10 +2,7 @@ import { z } from 'zod';
 import { zId } from './utils.js';
 
 
-/**
- * @typedef {import('zod').infer<typeof entityApiConfigurationSchema>} IEntityApiConfiguration
- */
-export const entityApiConfigurationSchema = z.object({
+export const EntityApiConfigurationSchema = z.object({
   // path: z.string(),
   GET: z.boolean().optional(),
   UPDATE: z.boolean().optional(),
@@ -15,17 +12,17 @@ export const entityApiConfigurationSchema = z.object({
   DELETE: z.boolean().optional()
 }).nullable();
 
-const entityConfigurationDefinitionSchema = z.object({
+const EntityConfigurationDefinitionSchema = z.object({
   utterance: zId('Utterance', z.string({description: 'What entity utterance this represents, if not provided, it will default to the entity id'}))
     .optional(),
   value: z.string({description: 'The value of this entity variance'}),
   text: z.array(z.string(), {description: 'Text representing the entity variance'})
 });
-const entityConfigurationTrainingSchema = z.object({
+const EntityConfigurationTrainingSchema = z.object({
   intent: zId('Intent', z.string({description: 'The assigned intent id of the given text, e.g. "I love %pizza%" could have an intent id "feedback" and "Can I purchase a %pizza%?" could have an intent id "purchase"'})),
   text: z.string({description: 'Text to train the intent field and entities in or entity variances in example sentences or phrase. Ex: "I love %pizza%" and "Can I purchase a %pizza%?"'})
 });
-const entityConfigurationTestSchema = z.object({
+const EntityConfigurationTestSchema = z.object({
   text: z.string({description: 'Text to test the entity detection'}),
   expected: z.object({
     intent: zId('Intent', z.string({description: 'The expected intent id'})),
@@ -33,17 +30,14 @@ const entityConfigurationTestSchema = z.object({
     context: z.any()
   })
 });
-const _entityConfigurationSchema = z.object({
+const _EntityConfigurationSchema = z.object({
   id: zId('Id', z.string({description: 'If not provided, the id will default to the route (folder) name'})).optional(),
-  definitions: z.array(entityConfigurationDefinitionSchema).optional(),
-  training: z.array(entityConfigurationTrainingSchema).optional(),
-  tests: z.array(entityConfigurationTestSchema).optional()
+  definitions: z.array(EntityConfigurationDefinitionSchema).optional(),
+  training: z.array(EntityConfigurationTrainingSchema).optional(),
+  tests: z.array(EntityConfigurationTestSchema).optional()
 }).strict();
 
-/**
- * @typedef {import('zod').infer<typeof entityConfigurationSchema>} IEntityConfiguration
- */
-export const entityConfigurationSchema = _entityConfigurationSchema.refine((data) => {
+export const EntityConfigurationSchema = _EntityConfigurationSchema.refine((data) => {
   // If 'definitions' is provided, then 'training' must also be provided
   if (data.definitions !== undefined) {
     return data.training !== undefined;
@@ -55,28 +49,24 @@ export const entityConfigurationSchema = _entityConfigurationSchema.refine((data
   message: "If 'definitions' is provided, then 'training' must also be provided",
 });
 
-/**
- * @typedef {import('zod').infer<typeof entitiesRootConfigurationSchema>} IEntitiesRootConfiguration
- */
-export const entitiesRootConfigurationSchema = z.array(entityConfigurationSchema);
+export const EntitiesRootConfigurationSchema = z.array(EntityConfigurationSchema);
 
 
-const entityExtendedProjectConfigurationSchema = z.object({
+const EntityExtendedProjectConfigurationSchema = z.object({
   entities: z.array(zId('Entity Folder', z.string()), {description: 'Entity id association, used to handle route params'})
     .min(1, 'Must have at least 1 entity')
     .max(15, 'Cannot have more than 15 entity paths'),
   entity: zId('Entity Folder', z.string()),
-  api: entityApiConfigurationSchema
+  api: EntityApiConfigurationSchema
 });
 
-const _entityRootProjectConfigurationSchema = _entityConfigurationSchema.extend(entityExtendedProjectConfigurationSchema.shape);
-const _entitiesRootProjectConfigurationSchema = z.array(_entityRootProjectConfigurationSchema);
+const _EntityRootProjectConfigurationSchema = _EntityConfigurationSchema.extend(EntityExtendedProjectConfigurationSchema.shape);
+const _EntitiesRootProjectConfigurationSchema = z.array(_EntityRootProjectConfigurationSchema);
 
 /**
  * @TODO why type extend not valid?
- * @typedef {import('zod').infer<typeof entityRootProjectConfigurationSchema>} IEntityRootProjectConfiguration
  */
-export const entityRootProjectConfigurationSchema = _entityConfigurationSchema.extend(entityExtendedProjectConfigurationSchema.shape).refine((data) => {
+export const EntityRootProjectConfigurationSchema = _EntityConfigurationSchema.extend(EntityExtendedProjectConfigurationSchema.shape).refine((data) => {
   // If 'definitions' is provided, then 'training' must also be provided
   if (data.definitions !== undefined) {
     return data.training !== undefined;
@@ -88,7 +78,4 @@ export const entityRootProjectConfigurationSchema = _entityConfigurationSchema.e
   message: "If 'definitions' is provided, then 'training' must also be provided",
 });
 
-/**
- * @typedef {import('zod').infer<typeof entitiesRootProjectConfigurationSchema>} IEntitiesRootProjectConfiguration
- */
-export const entitiesRootProjectConfigurationSchema = z.array(entityRootProjectConfigurationSchema);
+export const EntitiesRootProjectConfigurationSchema = z.array(EntityRootProjectConfigurationSchema);

package/src/runtime/schemas/index.js

@@ -0,0 +1,9 @@
+export * from './users.js';
+export * from './api.js';
+export * from './config.js';
+export * from './entity.js';
+export * from './message.js';
+export * from './workflow.js';
+export * from './platform.js';
+export * from './macros.js';
+

package/src/runtime/{client → schemas}/message.js

@@ -1,9 +1,6 @@
 import { z } from 'zod';
 import { zId } from './utils.js';
 
-/**
- * @typedef {import('zod').infer<typeof MessageSchema>} IMessage
- */
 export const MessageSchema = z.object({
   id: zId('Message ID', {description: 'Unique ID for the message'}),
   role: z.enum(['agent', 'customer', 'system']),

package/src/runtime/{client → schemas}/platform.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { eventResponseSchema, EventResponse } from './api.js';
+import { eventResponseSchema } from './api.js';
 
 
 /**