@scout9/app 1.0.0-alpha.0.1.85 → 1.0.0-alpha.0.1.87

package/src/runtime/client/api.js

@@ -1,184 +1,57 @@
-
-// export type Scout9Response =
-// export type RequestHandler<
-//   RequestBody = unknown,
-//   ResponseBody = Record<string | number, any> | Record<string | number, any>[],
-//   Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
-//   RouteId extends string | null = string | null,
-//   SearchParams extends Partial<Record<string, string | string[]>> = Partial<Record<string, string>>
-// > = (event: EventRequest<RequestBody, Params, RouteId, SearchParams>) => MaybePromise<EventResponse<ResponseBody>>;
-//
-// /**
-//  * For QUERY entity api calls, this is used for getting multiple entities
-//  */
-// export type QueryRequestHandler<
-//   ResponseBody = Record<string | number, any>,
-//   Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
-//   RouteId extends string | null = string | null,
-// > = RequestHandler<unknown, ResponseBody[], Params, RouteId, {q?: string, page?: string, limit?: string, orderBy?: string, endAt?: string, startAt?: string}>;
-//
-// /**
-//  * For GET entity api calls, this is used for getting one entity
-//  */
-// export type GetRequestHandler<
-//   ResponseBody = Record<string | number, any>,
-//   Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
-//   RouteId extends string | null = string | null,
-// > = RequestHandler<unknown, ResponseBody, Params, RouteId>;
-//
-// /**
-//  * For POST entity api calls, this is used for creating an entity
-//  */
-// export type PostRequestHandler<
-//   RequestBody = Record<string | number, any>,
-//   Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
-//   RouteId extends string | null = string | null
-// > = RequestHandler<RequestBody, {success: boolean, id: string, error?: string | object, [key: string]: any}, Params, RouteId>;
-//
-// export type CreatedRequestHandler<
-//   RequestBody = Record<string | number, any>,
-//   Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
-//   RouteId extends string | null = string | null
-// > = PostRequestHandler<RequestBody, Params, RouteId>;
-//
-//
-// /**
-//  * For PUT entity api calls, this is used for creating an entity
-//  */
-// export type PutRequestHandler<
-//   RequestBody = Record<string | number, any>,
-//   Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
-//   RouteId extends string | null = string | null
-// > = RequestHandler<Partial<RequestBody>, {success: boolean, error?: string | object, [key: string]: any}, Params, RouteId>;
-//
-//
-// /**
-//  * For PUT entity api calls, this is used for creating an entity
-//  */
-// export type PatchRequestHandler<
-//   RequestBody = Record<string | number, any>,
-//   Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
-//   RouteId extends string | null = string | null
-// > = PutRequestHandler<RequestBody, Params, RouteId>;
-//
-// /**
-//  * For PUT entity api calls, this is used for creating an entity
-//  */
-// export type UpdateRequestHandler<
-//   RequestBody = Record<string | number, any>,
-//   Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
-//   RouteId extends string | null = string | null
-// > = PutRequestHandler<RequestBody, Params, RouteId>;
-//
-// /**
-//  * For PUT entity api calls, this is used for creating an entity
-//  */
-// export type DeleteRequestHandler<
-//   Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
-//   RouteId extends string | null = string | null
-// > = RequestHandler<unknown, {success: boolean, error?: string | object, [key: string]: any}, Params, RouteId>;
-//
-//
-// export interface EventRequest<
-//   Body = unknown,
-//   Params extends Partial<Record<string, string>> = Partial<Record<string, string>>,
-//   RouteId extends string | null = string | null,
-//   SearchParams extends Partial<Record<string, string | string[]>> = Partial<Record<string, string>>,
-// > {
-//
-//   /**
-//    * `fetch` is equivalent to the [native `fetch` web API](https://developer.mozilla.org/en-US/docs/Web/API/fetch), with a few additional features:
-//    *
-//    * - It can be used to make credentialed requests on the server, as it inherits the `cookie` and `authorization` headers for the page request.
-//    * - It can make relative requests on the server (ordinarily, `fetch` requires a URL with an origin when used in a server context).
-//    * - Internal requests (e.g. for `+server.js` routes) go directly to the handler function when running on the server, without the overhead of an HTTP call.
-//    * - During server-side rendering, the response will be captured and inlined into the rendered HTML by hooking into the `text` and `json` methods of the `Response` object. Note that headers will _not_ be serialized, unless explicitly included
-//    * - During hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request.
-//    *
-//    */
-//   fetch: typeof fetch;
-//
-//   /**
-//    * The parameters of the current route - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object
-//    */
-//   params: Params;
-//
-//   /**
-//    * The requested URL.
-//    */
-//   url: URL;
-//
-//   /**
-//    * The anticipated searchParams inside `const { searchParams } = new URL(req.url)`
-//    */
-//   searchParams: SearchParams;
-//
-//   /**
-//    * The anticipated parsed body inside `request.body`
-//    */
-//   body: Body;
-//
-//   /**
-//    * The original request object
-//    */
-//   request: Request;
-//
-//   /**
-//    * If you need to set headers for the response, you can do so using the this method. This is useful if you want the page to be cached, for example:
-//    *
-//    *	```js
-//    *	/// file: src/routes/blog/+page.js
-//    *	export async function load({ fetch, setHeaders }) {
-//    *		const url = `https://cms.example.com/articles.json`;
-//    *		const response = await fetch(url);
-//    *
-//    *		setHeaders({
-//    *			age: response.headers.get('age'),
-//    *			'cache-control': response.headers.get('cache-control')
-//    *		});
-//    *
-//    *		return response.json();
-//    *	}
-//    *	```
-//    *
-//    * Setting the same header multiple times (even in separate `load` functions) is an error — you can only set a given header once.
-//    *
-//    * You cannot add a `set-cookie` header with `setHeaders` API instead.
-//    */
-//   setHeaders(headers: Record<string, string>): void;
-//
-//   /**
-//    * Info about the current route
-//    */
-//   route: {
-//     /**
-//      * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`
-//      */
-//     id: RouteId;
-//   };
-// }
+import { z } from 'zod';
 
 /**
  * Utility runtime class used to guide event output
+ * @template T
  */
 export class EventResponse {
 
+  /**
+   * Create a new EventResponse instance with a JSON body.
+   * @template T
+   * @param {T} body - The body of the response.
+   * @param {ResponseInit} [options] - Additional options for the response.
+   * @returns {EventResponse<T>} A new EventResponse instance.
+   */
   static json(body, options) {
     return new EventResponse(body, options);
   }
 
+  /**
+   * Create an EventResponse.
+   * @param {T} body - The body of the response.
+   * @param {ResponseInit} [init] - Additional options for the response.
+   * @throws {Error} If the body is not a valid object.
+   */
   constructor(body, init) {
+    /**
+     * @type {T}
+     * @private
+     */
     this.body = body;
+
+    /**
+     * @type {ResponseInit}
+     * @private
+     */
     this.init = init;
     if (typeof this.body !== 'object') {
       throw new Error(`EventResponse body in not a valid object:\n"${JSON.stringify(body, null, 2)}"`);
     }
   }
 
+  /**
+   * Get the response object.
+   * @returns {Response} The response object.
+   */
   get response() {
     return Response.json(this.body, this.init);
   }
 
+  /**
+   * Get the data of the response.
+   * @returns {T} The body of the response.
+   */
   get data() {
     return this.body;
   }
@@ -186,3 +59,22 @@ 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/config.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { agentsConfigurationSchema, agentsBaseConfigurationSchema } from './agent.js';
+import { agentsConfigurationSchema, agentsBaseConfigurationSchema } from './users.js';
 import { entitiesRootProjectConfigurationSchema } from './entity.js';
 import { WorkflowsConfigurationSchema } from './workflow.js';
 
@@ -40,21 +40,46 @@ const bardSchema = z.object({
   model: z.string()
 });
 
+/**
+ * Configure personal model transformer (PMT) settings to align auto replies the agent's tone
+ */
 const pmtSchema = z.object({
   engine: z.literal('scout9'),
   // model: pmtModelOptions
   model: z.string()
+}, {
+  description: 'Configure personal model transformer (PMT) settings to align auto replies the agent\'s tone'
 });
 
-export const Scout9ProjectBuildConfigSchema = 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({
+  /**
+   * Tag to reference this application
+   * @defaut your local package.json name + version, or scout9-app-v1.0.0
+   */
   tag: z.string().optional(), // Defaults to scout9-app-v1.0.0
-  agents: agentsBaseConfigurationSchema,
-  entities: entitiesRootProjectConfigurationSchema,
-  workflows: WorkflowsConfigurationSchema,
   llm: z.union([llmSchema, llamaSchema, bardSchema]),
+  /**
+   * Configure personal model transformer (PMT) settings to align auto replies the agent's tone
+   */
   pmt: pmtSchema,
-  initialContext: z.array(z.string()),
-  maxLockAttempts: z.number().min(0).max(20).optional(),
+
+  /**
+   * Determines the max auto replies without further conversation progression (defined by new context data gathered)
+   * before the conversation is locked and requires manual intervention
+   * @default 3
+   */
+  maxLockAttempts: z.number({
+    description: 'Determines the max auto replies without further conversation progression (defined by new context data gathered), before the conversation is locked and requires manual intervention'
+  }).min(0).max(20).default(3).optional(),
+
+  initialContext: z.array(z.string(), {
+    description: 'Configure the initial contexts for every conversation'
+  }),
+
   organization: z.object({
     name: z.string(),
     description: z.string(),
@@ -66,4 +91,15 @@ export const Scout9ProjectBuildConfigSchema = z.object({
     email: z.string().email().optional(),
     phone: z.string().optional(),
   }).optional()
+})
+
+/**
+ * @typedef {import('zod').infer<typeof Scout9ProjectBuildConfigSchema>} IScout9ProjectBuildConfig
+ */
+export const Scout9ProjectBuildConfigSchema = Scout9ProjectConfigSchema.extend({
+  agents: agentsBaseConfigurationSchema,
+  entities: entitiesRootProjectConfigurationSchema,
+  workflows: WorkflowsConfigurationSchema
 });
+
+

package/src/runtime/client/entity.js

@@ -2,7 +2,10 @@ import { z } from 'zod';
 import { zId } from './utils.js';
 
 
-export const _entityApiConfigurationSchema = z.object({
+/**
+ * @typedef {import('zod').infer<typeof entityApiConfigurationSchema>} IEntityApiConfiguration
+ */
+export const entityApiConfigurationSchema = z.object({
   // path: z.string(),
   GET: z.boolean().optional(),
   UPDATE: z.boolean().optional(),
@@ -10,9 +13,7 @@ export const _entityApiConfigurationSchema = z.object({
   PUT: z.boolean().optional(),
   PATCH: z.boolean().optional(),
   DELETE: z.boolean().optional()
-})
-
-export const entityApiConfigurationSchema = _entityApiConfigurationSchema.nullable();
+}).nullable();
 
 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'}))
@@ -39,6 +40,9 @@ const _entityConfigurationSchema = z.object({
   tests: z.array(entityConfigurationTestSchema).optional()
 }).strict();
 
+/**
+ * @typedef {import('zod').infer<typeof entityConfigurationSchema>} IEntityConfiguration
+ */
 export const entityConfigurationSchema = _entityConfigurationSchema.refine((data) => {
   // If 'definitions' is provided, then 'training' must also be provided
   if (data.definitions !== undefined) {
@@ -51,6 +55,9 @@ 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);
 
 
@@ -65,7 +72,10 @@ const entityExtendedProjectConfigurationSchema = z.object({
 const _entityRootProjectConfigurationSchema = _entityConfigurationSchema.extend(entityExtendedProjectConfigurationSchema.shape);
 const _entitiesRootProjectConfigurationSchema = z.array(_entityRootProjectConfigurationSchema);
 
-// @TODO why type extend not valid?
+/**
+ * @TODO why type extend not valid?
+ * @typedef {import('zod').infer<typeof entityRootProjectConfigurationSchema>} IEntityRootProjectConfiguration
+ */
 export const entityRootProjectConfigurationSchema = _entityConfigurationSchema.extend(entityExtendedProjectConfigurationSchema.shape).refine((data) => {
   // If 'definitions' is provided, then 'training' must also be provided
   if (data.definitions !== undefined) {
@@ -77,4 +87,8 @@ export const entityRootProjectConfigurationSchema = _entityConfigurationSchema.e
   // Custom error message
   message: "If 'definitions' is provided, then 'training' must also be provided",
 });
+
+/**
+ * @typedef {import('zod').infer<typeof entitiesRootProjectConfigurationSchema>} IEntitiesRootProjectConfiguration
+ */
 export const entitiesRootProjectConfigurationSchema = z.array(entityRootProjectConfigurationSchema);

package/src/runtime/client/index.js

@@ -1,7 +1,8 @@
-export * from './agent.js';
+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/client/message.js

@@ -1,8 +1,17 @@
 import { z } from 'zod';
+import { zId } from './utils.js';
 
+/**
+ * @typedef {import('zod').infer<typeof MessageSchema>} IMessage
+ */
 export const MessageSchema = z.object({
-  content: z.string(),
+  id: zId('Message ID', {description: 'Unique ID for the message'}),
   role: z.enum(['agent', 'customer', 'system']),
-  time: z.string(),
-  name: z.string().optional()
+  content: z.string(),
+  time: z.string({description: 'Datetime ISO 8601 timestamp'}),
+  name: z.string().optional(),
+  scheduled: z.string({description: 'Datetime ISO 8601 timestamp'}).optional(),
+  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(),
 });

package/src/runtime/client/platform.js

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import { eventResponseSchema, EventResponse } from './api.js';
+
+
+/**
+ * @typedef {object} IApiFunctionParams
+ * @property {Object.<string, string|string[]>} searchParams
+ * @property {Record<string, string>} params
+ */
+const apiFunctionParamsSchema = z.object({
+  searchParams: z.record(z.union([z.string(), z.array(z.string())])),
+  params: z.record(z.string())
+});
+
+/**
+ * @typedef {IApiFunctionParams & { id: string }} IApiEntityFunctionParams
+ */
+const apiEntityFunctionParamsSchema = apiFunctionParamsSchema.extend({
+  id: z.string()
+});
+
+/**
+ * @template Params
+ * @template Response
+ * @typedef {function(IApiFunctionParams): Promise<EventResponse>} IApiFunction
+ */
+export const apiFunctionSchema = z.function()
+  .args(apiFunctionParamsSchema)
+  .returns(z.promise(eventResponseSchema));
+
+/**
+ * @template Params
+ * @template Response
+ * @typedef {IApiFunction<Params, Response>} IQueryApiFunction
+ */
+export const queryApiFunctionSchema = apiFunctionSchema;
+
+/**
+ * @template Params
+ * @template Response
+ * @typedef {IApiFunction<Params, Response>} GetApiFunction
+ */
+export const getApiFunctionSchema = apiFunctionSchema;
+
+/**
+ * @template Params
+ * @template RequestBody
+ * @template Response
+ * @typedef {function(IApiFunctionParams & {body: Partial<RequestBody>}): Promise<EventResponse<Response>>} IPostApiFunction
+ */
+export const postApiFunctionSchema = (requestBodySchema) => z.function()
+  .args(apiFunctionParamsSchema.extend({
+    body: requestBodySchema.partial()
+  }))
+  .returns(z.promise(eventResponseSchema));
+
+/**
+ * @template Params
+ * @template RequestBody
+ * @template Response
+ * @typedef {function(IApiFunctionParams & {body: Partial<RequestBody>}): Promise<EventResponse<Response>>} IPutApiFunction
+ */
+export const putApiFunctionSchema = (requestBodySchema) => z.function()
+  .args(apiFunctionParamsSchema.extend({
+    body: requestBodySchema.partial()
+  }))
+  .returns(z.promise(eventResponseSchema));
+
+/**
+ * @template Params
+ * @template RequestBody
+ * @template Response
+ * @typedef {function(IApiFunctionParams & {body: Partial<RequestBody>}): Promise<EventResponse<Response>>} IPatchApiFunction
+ */
+export const patchApiFunctionSchema = (requestBodySchema) => z.function()
+  .args(apiFunctionParamsSchema.extend({
+    body: requestBodySchema.partial()
+  }))
+  .returns(z.promise(eventResponseSchema));
+
+/**
+ * @template Params
+ * @template Response
+ * @typedef {IApiFunction<Params, Response>} IDeleteApiFunction
+ */
+export const deleteApiFunctionSchema = apiFunctionSchema;

package/src/runtime/client/{agent.js → users.js}

@@ -2,8 +2,14 @@ import { z } from 'zod';
 import { zId } from './utils.js';
 import { MessageSchema } from './message.js';
 
+/**
+ * @typedef {import('zod').infer<typeof customerValueSchema>} ICustomerValue
+ */
 export const customerValueSchema = z.union([z.boolean(), z.number(), z.string()]);
 
+/**
+ * @typedef {import('zod').infer<typeof customerSchema>} ICustomer
+ */
 export const customerSchema = z.object({
   firstName: z.string().optional(),
   lastName: z.string().optional(),
@@ -24,13 +30,16 @@ export const customerSchema = z.object({
   stripeDev: z.string().nullable().optional()
 }).catchall(customerValueSchema);
 
-
+/**
+ * @typedef {import('zod').infer<typeof agentBaseConfigurationSchema>} IAgentBase
+ */
 export const agentBaseConfigurationSchema = z.object({
   deployed: z.object({
     web: z.string({description: 'Web URL for agent'}).optional(),
     phone: z.string({description: 'Phone number for agent'}).optional(),
     email: z.string({description: 'Email address for agent'}).optional()
   }).optional(),
+  img: z.string().nullable().optional(),
   firstName: z.string({description: 'Agent first name'}).optional(),
   lastName: z.string({description: 'Agent last name'}).optional(),
   inactive: z.boolean({description: 'Agent is inactive'}).optional(),
@@ -46,11 +55,23 @@ export const agentBaseConfigurationSchema = z.object({
   model: z.enum(['Scout9', 'bard', 'openai']).optional().default('openai'),
   transcripts: z.array(z.array(MessageSchema)).optional(),
   audios: z.array(z.any()).optional()
-
 });
+
+/**
+ * @typedef {import('zod').infer<typeof agentBaseConfigurationSchema>} IAgent
+ * @typedef {import('zod').infer<typeof agentBaseConfigurationSchema>} IPersona
+ */
 export const agentConfigurationSchema = agentBaseConfigurationSchema.extend({
-  id: zId('Agent ID', z.string({description: 'Unique ID for agent'})),
-})
+  id: zId('Agent ID', {description: 'Unique ID for agent'}),
+});
+
+/**
+ * @typedef {import('zod').infer<typeof agentsConfigurationSchema>} IAgentsConfiguration
+ */
 export const agentsConfigurationSchema = z.array(agentConfigurationSchema);
 
+/**
+ * @typedef {import('zod').infer<typeof agentsBaseConfigurationSchema>} IAgentsBaseConfiguration
+ */
 export const agentsBaseConfigurationSchema = z.array(agentBaseConfigurationSchema);
+

package/src/runtime/client/utils.js

@@ -1,12 +1,12 @@
 import { z } from 'zod';
 
 /**
- *
  * @param {string} name
- * @returns {ZodString}
+ * @param {Object} [props]
+ * @returns {import('zod').ZodString}
  */
-export function zId(name) {
-  return z.string().regex(/^[A-Za-z0-9\-_\[\]]+$/, {
+export function zId(name, props = {}) {
+  return z.string(props).regex(/^[A-Za-z0-9\-_\[\]]+$/, {
     message: `Invalid ${name} ID: ID must not contain spaces and should only contain alphanumeric characters, dashes, or underscores.`
   });
 }