@scout9/app 1.0.0-alpha.0.1.9 → 1.0.0-alpha.0.1.91

package/src/report.js

@@ -0,0 +1,117 @@
+import { red, cyan, green, dim, white, grey, bold, italic, magenta, yellow } from 'kleur/colors';
+import { ProgressLogger } from './utils/index.js';
+
+/**
+ *
+ * @param {import('zod').ZodError} zodError
+ * @param {string} source
+ */
+export function logUserValidationError(
+  zodError,
+  source,
+) {
+  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) {
+    const pathStr = path.join('.');
+    let text = '';
+    const objectPath = red(`${italic('.' + pathStr)}`) + grey(':');
+    switch (code) {
+      case 'invalid_type':
+        text = `Expected type ${cyan(expected)} but received ${yellow(received)}.`;
+        break;
+      case 'invalid_enum':
+        text = `Expected one of ${expected.map(e => cyan(e)).join(', ')} but received ${yellow(received)}.`;
+        break;
+      default:
+        text = yellow(`(${code}) ${message} .${pathStr}`);
+    }
+    console.log('\t', objectPath, grey(`${text}`));
+  }
+}
+
+
+/**
+ * @param {Scout9ProjectBuildConfig} config
+ * @param {ProgressLogger} logger
+ */
+export function report(config, logger) {
+  logger.primary(`${white('Scout9 App For:')} ${cyan(config.organization.name)} ${magenta(config.tag)}`);
+  if (config.organization?.dashboard) {
+    logger.info(`Dashboard: ${cyan(config.organization.dashboard)}`);
+  }
+  logger.info(`LLM Engine: ${cyan(config.llm.engine)} ${magenta(config.llm.model)}`);
+  logger.info(`PMT Engine: ${cyan(config.pmt.engine)} ${magenta(config.pmt.model)}`);
+  logger.info(`Max Lock Attempts: ${cyan(config?.maxLockAttempts || 3)}`);
+  logger.info(`Initial Context:\n\t\t${(config?.initialContext || []).map(i => `${white('-')} ${magenta('"')}${italic(i)}${magenta('"')}`).join('\n\t\t')}`);
+  // logger.primary(`${config.agents.length} Persona${config.agents.length > 1 ? 's' : ''}\n\n`);
+  for (const agent of config.agents) {
+    logger.primary(`${grey('Persona: ')}${agent.firstName}${agent.lastName ? ' ' + agent.lastName : ''}`);
+    logger.info(`Context: ${magenta('"')}${italic(agent.context)}${magenta('"')}`);
+    let phone = agent.deployed?.phone || agent?.programmablePhoneNumber || '';
+    phone = phone ? cyan(phone) : '';
+    const phoneForward = agent.forwardPhone ? magenta(agent.forwardPhone) : red('Not Configured');
+
+    const web = agent?.deployed?.web ? cyan(agent.deployed.web) : red('Not Configured');
+    let email = agent.deployed?.email || agent?.programmableEmail || '';
+    email = email ? cyan(email) : red('None Configured');
+    const emailForward = agent.forwardEmail ? magenta(agent.forwardEmail) : red('Not Configured');
+    logger.info(`Web: ${web}`);
+    if (phone) {
+      logger.info(`Phone: ${phone} --> ${italic('forwards to')} ${dim(phoneForward)}`);
+    }
+    if (email) {
+      logger.info(`Email: ${email} --> ${italic('forwards to')} ${emailForward}`);
+    }
+  }
+  // logger.primary(`\n\n${config.entities.length} ${config.entities.length > 1 ? 'Entities' : 'Entity'}\n\n`);
+
+  for (const entityConfig of config.entities) {
+    const {entity, api, entities, training, tests, definitions} = entityConfig;
+    const parents = entities.slice(0, -1).join('/')
+    logger.primary(`${grey('Entity: ')}${parents}/${magenta(entity)}`);
+    if (definitions && definitions.length > 0) {
+      logger.info(`${cyan(definitions.length)} definition${definitions.length > 1 ? 's' : ''}`);
+    }
+    if (training && training.length > 0) {
+      logger.info(`${cyan(training.length)} training phrase${training.length > 1 ? 's' : ''}`);
+    }
+    if (tests && tests.length > 0) {
+      logger.info(`${cyan(tests.length)} test${tests.length > 1 ? 's' : ''}`);
+    }
+    if (!api) {
+      logger.info(`${cyan('0')} api's exported`);
+    }
+    if (api?.QUERY) {
+      logger.info(`${cyan('QUERY')}: ${api.QUERY ? green('on') : red('off')}`);
+    }
+    if (api?.GET) {
+      logger.info(`${cyan('GET')}: ${api.GET ? green('on') : red('off')}`);
+    }
+    if (api?.POST) {
+      logger.info(`${cyan('POST')}: ${api.POST ? green('on') : red('off')}`);
+    }
+    if (api?.PUT) {
+      logger.info(`${cyan('PUT')}: ${api.PUT ? green('on') : red('off')}`);
+    }
+    if (api?.PATCH) {
+      logger.info(`${cyan('PATCH')}: ${api.PATCH ? green('on') : red('off')}`);
+    }
+    if (api?.DELETE) {
+      logger.info(`${cyan('DELETE')}: ${api.DELETE ? green('on') : red('off')}`);
+    }
+  }
+
+  for (const workflowConfig of config.workflows) {
+    const {entity, api, entities } = workflowConfig;
+    const parents = entities.slice(0, -1).join('/')
+    logger.primary(`${grey('Workflow: ')}${parents}/${magenta(entity)}`);
+    if (!api) {
+      logger.info(`${cyan('0')} api's exported`);
+    }
+  }
+
+  logger.primary(`Run ${cyan('scout9 dev')} to test your project locally`);
+
+}

package/src/runtime/client/api.js

@@ -1,183 +1,80 @@
-
-// 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;
+  }
+
 }
 
 
+
+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,9 +1,7 @@
-import { Agent } from '@scout9/app';
 import { z } from 'zod';
-import { zId } from './utils.js';
-import { agentsConfigurationSchema } from './agent.js';
-import { entitiesRootConfigurationSchema, entitiesRootProjectConfigurationSchema } from './entity.js';
-import { WorkflowConfigurationSchema } from './workflow.js';
+import { agentsBaseConfigurationSchema } from './users.js';
+import { entitiesRootProjectConfigurationSchema } from './entity.js';
+import { WorkflowsConfigurationSchema } from './workflow.js';
 
 const llmModelOptions = z.union([
   z.literal('gpt-4-1106-preview'),
@@ -42,15 +40,66 @@ 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: pmtModelOptions
+  model: z.string()
+}, {
+  description: 'Configure personal model transformer (PMT) settings to align auto replies the agent\'s tone'
 });
 
-export const Scout9ProjectBuildConfigSchema = z.object({
-  agents: agentsConfigurationSchema,
-  entities: entitiesRootProjectConfigurationSchema,
-  workflows: WorkflowConfigurationSchema,
+/**
+ * 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
   llm: z.union([llmSchema, llamaSchema, bardSchema]),
-  pmt: pmtSchema
+  /**
+   * Configure personal model transformer (PMT) settings to align auto replies the agent's tone
+   */
+  pmt: pmtSchema,
+
+  /**
+   * 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(),
+    dashboard: z.string().optional(),
+    logo: z.string().optional(),
+    icon: z.string().optional(),
+    logos: z.string().optional(),
+    website: z.string().optional(),
+    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

@@ -1,9 +1,11 @@
 import { z } from 'zod';
 import { zId } from './utils.js';
-import { ConversationContext } from './workflow.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(),
@@ -11,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'}))
@@ -40,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) {
@@ -52,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);
 
 
@@ -66,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) {
@@ -78,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,6 +1,8 @@
+export * from './users.js';
 export * from './api.js';
-export * from './workflow.js';
-export * from './agent.js';
-export * from './entity.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,18 @@
 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(),
+  delayInSeconds: z.number({description: 'How long to delay the message manually in seconds'}).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;