@lorikeetai/node-sdk 0.1.0-alpha.2 → 0.1.0-alpha.7

package/src/internal/qs/utils.ts

@@ -1,49 +1,49 @@
-import { RFC1738 } from './formats';
-import type { DefaultEncoder, Format } from './types';
+import { RFC1738 } from './formats'
+import type { DefaultEncoder, Format } from './types'
 
-const has = Object.prototype.hasOwnProperty;
-const is_array = Array.isArray;
+const has = Object.prototype.hasOwnProperty
+const is_array = Array.isArray
 
 const hex_table = (() => {
-  const array = [];
+  const array = []
   for (let i = 0; i < 256; ++i) {
-    array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
+    array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase())
   }
 
-  return array;
-})();
+  return array
+})()
 
 function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; prop: string }>) {
   while (queue.length > 1) {
-    const item = queue.pop();
-    if (!item) continue;
+    const item = queue.pop()
+    if (!item) continue
 
-    const obj = item.obj[item.prop];
+    const obj = item.obj[item.prop]
 
     if (is_array(obj)) {
-      const compacted: unknown[] = [];
+      const compacted: unknown[] = []
 
       for (let j = 0; j < obj.length; ++j) {
         if (typeof obj[j] !== 'undefined') {
-          compacted.push(obj[j]);
+          compacted.push(obj[j])
         }
       }
 
       // @ts-ignore
-      item.obj[item.prop] = compacted;
+      item.obj[item.prop] = compacted
     }
   }
 }
 
 function array_to_object(source: any[], options: { plainObjects: boolean }) {
-  const obj = options && options.plainObjects ? Object.create(null) : {};
+  const obj = options && options.plainObjects ? Object.create(null) : {}
   for (let i = 0; i < source.length; ++i) {
     if (typeof source[i] !== 'undefined') {
-      obj[i] = source[i];
+      obj[i] = source[i]
     }
   }
 
-  return obj;
+  return obj
 }
 
 export function merge(
@@ -52,86 +52,86 @@ export function merge(
   options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
 ) {
   if (!source) {
-    return target;
+    return target
   }
 
   if (typeof source !== 'object') {
     if (is_array(target)) {
-      target.push(source);
+      target.push(source)
     } else if (target && typeof target === 'object') {
       if (
         (options && (options.plainObjects || options.allowPrototypes)) ||
         !has.call(Object.prototype, source)
       ) {
-        target[source] = true;
+        target[source] = true
       }
     } else {
-      return [target, source];
+      return [target, source]
     }
 
-    return target;
+    return target
   }
 
   if (!target || typeof target !== 'object') {
-    return [target].concat(source);
+    return [target].concat(source)
   }
 
-  let mergeTarget = target;
+  let mergeTarget = target
   if (is_array(target) && !is_array(source)) {
     // @ts-ignore
-    mergeTarget = array_to_object(target, options);
+    mergeTarget = array_to_object(target, options)
   }
 
   if (is_array(target) && is_array(source)) {
     source.forEach(function (item, i) {
       if (has.call(target, i)) {
-        const targetItem = target[i];
+        const targetItem = target[i]
         if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
-          target[i] = merge(targetItem, item, options);
+          target[i] = merge(targetItem, item, options)
         } else {
-          target.push(item);
+          target.push(item)
         }
       } else {
-        target[i] = item;
+        target[i] = item
       }
-    });
-    return target;
+    })
+    return target
   }
 
   return Object.keys(source).reduce(function (acc, key) {
-    const value = source[key];
+    const value = source[key]
 
     if (has.call(acc, key)) {
-      acc[key] = merge(acc[key], value, options);
+      acc[key] = merge(acc[key], value, options)
     } else {
-      acc[key] = value;
+      acc[key] = value
     }
-    return acc;
-  }, mergeTarget);
+    return acc
+  }, mergeTarget)
 }
 
 export function assign_single_source(target: any, source: any) {
   return Object.keys(source).reduce(function (acc, key) {
-    acc[key] = source[key];
-    return acc;
-  }, target);
+    acc[key] = source[key]
+    return acc
+  }, target)
 }
 
 export function decode(str: string, _: any, charset: string) {
-  const strWithoutPlus = str.replace(/\+/g, ' ');
+  const strWithoutPlus = str.replace(/\+/g, ' ')
   if (charset === 'iso-8859-1') {
     // unescape never throws, no try...catch needed:
-    return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+    return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape)
   }
   // utf-8
   try {
-    return decodeURIComponent(strWithoutPlus);
+    return decodeURIComponent(strWithoutPlus)
   } catch (e) {
-    return strWithoutPlus;
+    return strWithoutPlus
   }
 }
 
-const limit = 1024;
+const limit = 1024
 
 export const encode: (
   str: any,
@@ -143,29 +143,29 @@ export const encode: (
   // This code was originally written by Brian White for the io.js core querystring library.
   // It has been adapted here for stricter adherence to RFC 3986
   if (str.length === 0) {
-    return str;
+    return str
   }
 
-  let string = str;
+  let string = str
   if (typeof str === 'symbol') {
-    string = Symbol.prototype.toString.call(str);
+    string = Symbol.prototype.toString.call(str)
   } else if (typeof str !== 'string') {
-    string = String(str);
+    string = String(str)
   }
 
   if (charset === 'iso-8859-1') {
     return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
-      return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
-    });
+      return '%26%23' + parseInt($0.slice(2), 16) + '%3B'
+    })
   }
 
-  let out = '';
+  let out = ''
   for (let j = 0; j < string.length; j += limit) {
-    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
-    const arr = [];
+    const segment = string.length >= limit ? string.slice(j, j + limit) : string
+    const arr = []
 
     for (let i = 0; i < segment.length; ++i) {
-      let c = segment.charCodeAt(i);
+      let c = segment.charCodeAt(i)
       if (
         c === 0x2d || // -
         c === 0x2e || // .
@@ -176,90 +176,90 @@ export const encode: (
         (c >= 0x61 && c <= 0x7a) || // A-Z
         (format === RFC1738 && (c === 0x28 || c === 0x29)) // ( )
       ) {
-        arr[arr.length] = segment.charAt(i);
-        continue;
+        arr[arr.length] = segment.charAt(i)
+        continue
       }
 
       if (c < 0x80) {
-        arr[arr.length] = hex_table[c];
-        continue;
+        arr[arr.length] = hex_table[c]
+        continue
       }
 
       if (c < 0x800) {
-        arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)];
-        continue;
+        arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)]
+        continue
       }
 
       if (c < 0xd800 || c >= 0xe000) {
         arr[arr.length] =
-          hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)];
-        continue;
+          hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)]
+        continue
       }
 
-      i += 1;
-      c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
+      i += 1
+      c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff))
 
       arr[arr.length] =
         hex_table[0xf0 | (c >> 18)]! +
         hex_table[0x80 | ((c >> 12) & 0x3f)] +
         hex_table[0x80 | ((c >> 6) & 0x3f)] +
-        hex_table[0x80 | (c & 0x3f)];
+        hex_table[0x80 | (c & 0x3f)]
     }
 
-    out += arr.join('');
+    out += arr.join('')
   }
 
-  return out;
-};
+  return out
+}
 
 export function compact(value: any) {
-  const queue = [{ obj: { o: value }, prop: 'o' }];
-  const refs = [];
+  const queue = [{ obj: { o: value }, prop: 'o' }]
+  const refs = []
 
   for (let i = 0; i < queue.length; ++i) {
-    const item = queue[i];
+    const item = queue[i]
     // @ts-ignore
-    const obj = item.obj[item.prop];
+    const obj = item.obj[item.prop]
 
-    const keys = Object.keys(obj);
+    const keys = Object.keys(obj)
     for (let j = 0; j < keys.length; ++j) {
-      const key = keys[j]!;
-      const val = obj[key];
+      const key = keys[j]!
+      const val = obj[key]
       if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
-        queue.push({ obj: obj, prop: key });
-        refs.push(val);
+        queue.push({ obj: obj, prop: key })
+        refs.push(val)
       }
     }
   }
 
-  compact_queue(queue);
+  compact_queue(queue)
 
-  return value;
+  return value
 }
 
 export function is_regexp(obj: any) {
-  return Object.prototype.toString.call(obj) === '[object RegExp]';
+  return Object.prototype.toString.call(obj) === '[object RegExp]'
 }
 
 export function is_buffer(obj: any) {
   if (!obj || typeof obj !== 'object') {
-    return false;
+    return false
   }
 
-  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj))
 }
 
 export function combine(a: any, b: any) {
-  return [].concat(a, b);
+  return [].concat(a, b)
 }
 
 export function maybe_map<T>(val: T[], fn: (v: T) => T) {
   if (is_array(val)) {
-    const mapped = [];
+    const mapped = []
     for (let i = 0; i < val.length; i += 1) {
-      mapped.push(fn(val[i]!));
+      mapped.push(fn(val[i]!))
     }
-    return mapped;
+    return mapped
   }
-  return fn(val);
+  return fn(val)
 }

package/src/lib/generate-signature.ts

@@ -0,0 +1,13 @@
+import crypto from 'crypto'
+
+/**
+ * Generate a signature for a given payload using a secret key.
+ */
+export function generateSignature(payload: Buffer | string, secret: string) {
+  return crypto
+    .createHmac('sha256', secret)
+    .update(payload)
+    .digest('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+}

package/src/resource.ts

@@ -1,11 +1,11 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import type { Lorikeet } from './index';
+import type { Lorikeet } from './index'
 
 export class APIResource {
-  protected _client: Lorikeet;
+  protected _client: Lorikeet
 
   constructor(client: Lorikeet) {
-    this._client = client;
+    this._client = client
   }
 }

package/src/resources/conversation/chat.ts

@@ -1,83 +1,102 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../resource';
-import * as Core from '../../core';
-import * as ChatAPI from './chat';
+import { APIResource } from '../../resource'
+import * as Core from '../../core'
+import * as ChatAPI from './chat'
 
 export class Chat extends APIResource {
+  generate(body: ChatGenerateParams, options?: Core.RequestOptions): Core.APIPromise<ChatGenerateResponse> {
+    return this._client.post('/conversation/chat/message', { body, ...options })
+  }
+
+  get(query: ChatGetParams, options?: Core.RequestOptions): Core.APIPromise<ChatGetResponse> {
+    return this._client.get('/conversation/chat/message', { query, ...options })
+  }
+
+  start(body: ChatStartParams, options?: Core.RequestOptions): Core.APIPromise<ChatStartResponse> {
+    return this._client.post('/conversation/chat/create', { body, ...options })
+  }
+}
+
+export interface ChatGenerateResponse {
   /**
-   * Retrieves the latest conversation message for a given conversation ID.
+   * The ID of the conversation
    */
-  generate(
-    conversationId: string,
-    body: ChatGenerateParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<ConversationMessage> {
-    return this._client.post(`/conversation/chat/${conversationId}/generate`, { body, ...options });
-  }
+  conversationId: string
 
   /**
-   * Retrieves the latest conversation message for a given conversation ID.
+   * The timestamp of when the message was created in our system.
    */
-  get(conversationId: string, options?: Core.RequestOptions): Core.APIPromise<ConversationMessage> {
-    return this._client.get(`/conversation/chat/${conversationId}`, options);
-  }
+  createdAt: string
 
   /**
-   * Generates a new conversation ID.
+   * The message to be sent back to the user. If empty, the message is still being
+   * processed.
    */
-  start(body: ChatStartParams, options?: Core.RequestOptions): Core.APIPromise<ChatStartResponse> {
-    return this._client.post('/conversation/chat/start', { body, ...options });
-  }
+  message: string
 }
 
-export interface ConversationMessage {
-  actions?: Array<ConversationMessage.Action>;
+export interface ChatGetResponse {
+  /**
+   * The ID of the conversation
+   */
+  conversationId: string
 
   /**
-   * The message content.
+   * The timestamp of when the message was created in our system.
    */
-  message?: string;
+  createdAt: string
 
   /**
-   * The timestamp of the message.
+   * The message to be sent back to the user. If empty, the message is still being
+   * processed.
    */
-  timestamp?: string;
+  message: string
 }
 
-export namespace ConversationMessage {
-  export interface Action {
-    /**
-     * The label of the action.
-     */
-    label?: string;
-
-    /**
-     * The type of action.
-     */
-    type?: string;
-
-    /**
-     * The value of the action.
-     */
-    value?: string;
-  }
+export interface ChatStartResponse {
+  /**
+   * The ID of the conversation
+   */
+  conversationId: string
+
+  /**
+   * The timestamp of the when the conversation was created in our system.
+   */
+  createdAt: string
 }
 
-export interface ChatStartResponse {
+export interface ChatGenerateParams {
   /**
-   * The unique identifier of the created conversation.
+   * The ID of the conversation
    */
-  conversationId?: string;
+  conversationId: string
+
+  /**
+   * The message to be sent to the user. This endpoint supports markdown.
+   */
+  message: string
 }
 
-export type ChatGenerateParams = unknown;
+export interface ChatGetParams {
+  /**
+   * The ID of the conversation you need to poll.
+   */
+  conversationId: string
+}
 
-export type ChatStartParams = unknown;
+export interface ChatStartParams {
+  /**
+   * The ID of the customer. If omitted, a new customer will be created.
+   */
+  customerId: string
+}
 
 export namespace Chat {
-  export import ConversationMessage = ChatAPI.ConversationMessage;
-  export import ChatStartResponse = ChatAPI.ChatStartResponse;
-  export import ChatGenerateParams = ChatAPI.ChatGenerateParams;
-  export import ChatStartParams = ChatAPI.ChatStartParams;
+  export import ChatGenerateResponse = ChatAPI.ChatGenerateResponse
+  export import ChatGetResponse = ChatAPI.ChatGetResponse
+  export import ChatStartResponse = ChatAPI.ChatStartResponse
+  export import ChatGenerateParams = ChatAPI.ChatGenerateParams
+  export import ChatGetParams = ChatAPI.ChatGetParams
+  export import ChatStartParams = ChatAPI.ChatStartParams
 }

package/src/resources/conversation/conversation.ts

@@ -1,16 +1,18 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../resource';
-import * as ChatAPI from './chat';
+import { APIResource } from '../../resource'
+import * as ChatAPI from './chat'
 
 export class Conversation extends APIResource {
-  chat: ChatAPI.Chat = new ChatAPI.Chat(this._client);
+  chat: ChatAPI.Chat = new ChatAPI.Chat(this._client)
 }
 
 export namespace Conversation {
-  export import Chat = ChatAPI.Chat;
-  export import ConversationMessage = ChatAPI.ConversationMessage;
-  export import ChatStartResponse = ChatAPI.ChatStartResponse;
-  export import ChatGenerateParams = ChatAPI.ChatGenerateParams;
-  export import ChatStartParams = ChatAPI.ChatStartParams;
+  export import Chat = ChatAPI.Chat
+  export import ChatGenerateResponse = ChatAPI.ChatGenerateResponse
+  export import ChatGetResponse = ChatAPI.ChatGetResponse
+  export import ChatStartResponse = ChatAPI.ChatStartResponse
+  export import ChatGenerateParams = ChatAPI.ChatGenerateParams
+  export import ChatGetParams = ChatAPI.ChatGetParams
+  export import ChatStartParams = ChatAPI.ChatStartParams
 }

package/src/resources/conversation/index.ts

@@ -1,4 +1,12 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export { Conversation } from './conversation';
-export { ConversationMessage, ChatStartResponse, ChatGenerateParams, ChatStartParams, Chat } from './chat';
+export {
+  ChatGenerateResponse,
+  ChatGetResponse,
+  ChatStartResponse,
+  ChatGenerateParams,
+  ChatGetParams,
+  ChatStartParams,
+  Chat,
+} from './chat'
+export { Conversation } from './conversation'

package/src/resources/conversation.ts

@@ -1,5 +1,5 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../resource';
+import { APIResource } from '../resource'
 
 export class Conversation extends APIResource {}

package/src/resources/index.ts

@@ -1,5 +1,5 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export { Conversation } from './conversation/conversation';
-export { IngestValidateResponse, IngestValidateParams, IngestWebhooksParams, Ingest } from './ingest';
-export { TokenCreateParams, Token } from './token';
+export { Conversation } from './conversation/conversation'
+export { Ingest } from './ingest'
+export { TokenCreateParams, Token } from './token'

package/src/resources/ingest.ts

@@ -1,63 +1,13 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../resource';
-import * as Core from '../core';
-import * as IngestAPI from './ingest';
+import { APIResource } from '../resource'
+import * as Core from '../core'
 
 export class Ingest extends APIResource {
-  /**
-   * Validate your webhook is configured correctly
-   */
-  validate(
-    body: IngestValidateParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<IngestValidateResponse> {
-    return this._client.post('/ingest/validate', { body, ...options });
-  }
-
-  /**
-   * The url to post a return webhook request to. This url will be generated by
-   * Lorikeet and sent as a payload to your webhook
-   */
-  webhooks(
-    toolId: string,
-    ticketId: string,
-    body: IngestWebhooksParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<void> {
-    return this._client.post(`/ingest/${toolId}/${ticketId}`, {
-      body,
+  validate(options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.post('/ingest/validate', {
       ...options,
       headers: { Accept: '*/*', ...options?.headers },
-    });
+    })
   }
 }
-
-export interface IngestValidateResponse {
-  code?: 200;
-
-  /**
-   * The return data for the tool request.
-   */
-  data?: string;
-}
-
-export interface IngestValidateParams {
-  /**
-   * The return data for the tool request.
-   */
-  data: unknown;
-}
-
-export interface IngestWebhooksParams {
-  /**
-   * The return data for the tool request.
-   */
-  data: unknown;
-}
-
-export namespace Ingest {
-  export import IngestValidateResponse = IngestAPI.IngestValidateResponse;
-  export import IngestValidateParams = IngestAPI.IngestValidateParams;
-  export import IngestWebhooksParams = IngestAPI.IngestWebhooksParams;
-}