@lorikeetai/node-sdk 0.1.0-alpha.1 → 0.1.0-alpha.10

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

@@ -0,0 +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'
+
+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 {
+  /**
+   * The ID of the conversation
+   */
+  conversationId: string
+
+  /**
+   * The timestamp of when the message was created in our system.
+   */
+  createdAt: string
+
+  /**
+   * The message to be sent back to the user. If empty, the message is still being
+   * processed.
+   */
+  message: string
+}
+
+export interface ChatGetResponse {
+  /**
+   * The ID of the conversation
+   */
+  conversationId: string
+
+  /**
+   * The timestamp of when the message was created in our system.
+   */
+  createdAt: string
+
+  /**
+   * The message to be sent back to the user. If empty, the message is still being
+   * processed.
+   */
+  message: 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 ChatGenerateParams {
+  /**
+   * The ID of the conversation
+   */
+  conversationId: string
+
+  /**
+   * The message to be sent to the user. This endpoint supports markdown.
+   */
+  message: string
+}
+
+export interface ChatGetParams {
+  /**
+   * The ID of the conversation you need to poll.
+   */
+  conversationId: string
+}
+
+export interface ChatStartParams {
+  /**
+   * The ID of the customer. If omitted, a new customer will be created.
+   */
+  customerId: string
+}
+
+export namespace 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/conversation.ts

@@ -0,0 +1,18 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource'
+import * as ChatAPI from './chat'
+
+export class Conversation extends APIResource {
+  chat: ChatAPI.Chat = new ChatAPI.Chat(this._client)
+}
+
+export namespace Conversation {
+  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

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

package/src/resources/conversation.ts

@@ -1,62 +1,5 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../resource';
-import * as Core from '../core';
-import * as ConversationAPI from './conversation';
+import { APIResource } from '../resource'
 
-export class Conversation extends APIResource {
-  /**
-   * Adds a message to an existing conversation using the conversation ID.
-   */
-  message(
-    conversationId: string,
-    body: ConversationMessageParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<ConversationMessageResponse> {
-    return this._client.post(`/conversation/${conversationId}/message`, { body, ...options });
-  }
-
-  /**
-   * Generates a new conversation ID.
-   */
-  start(options?: Core.RequestOptions): Core.APIPromise<ConversationStartResponse> {
-    return this._client.post('/conversation/start', options);
-  }
-}
-
-export interface ConversationMessageResponse {
-  /**
-   * The ID of the conversation the message was added to.
-   */
-  conversationId?: string;
-
-  /**
-   * The content of the message.
-   */
-  message?: string;
-
-  /**
-   * The unique identifier of the added message.
-   */
-  messageId?: string;
-}
-
-export interface ConversationStartResponse {
-  /**
-   * The unique identifier of the created conversation.
-   */
-  conversationId?: string;
-}
-
-export interface ConversationMessageParams {
-  /**
-   * The message text to add to the conversation.
-   */
-  message?: string;
-}
-
-export namespace Conversation {
-  export import ConversationMessageResponse = ConversationAPI.ConversationMessageResponse;
-  export import ConversationStartResponse = ConversationAPI.ConversationStartResponse;
-  export import ConversationMessageParams = ConversationAPI.ConversationMessageParams;
-}
+export class Conversation extends APIResource {}

package/src/resources/index.ts

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

package/src/resources/ingest.ts

@@ -1,92 +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 {
-  /**
-   * The URL to post a return webhook request to. This URL will be generated by
-   * Lorikeet and sent as a payload to your webhook.
-   */
-  returnWebhook(
-    toolId: string,
-    ticketId: string,
-    body: IngestReturnWebhookParams,
-    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 },
-    });
+    })
   }
-
-  /**
-   * Create a signed JWT that can be associated with a user account.
-   */
-  token(body: IngestTokenParams, options?: Core.RequestOptions): Core.APIPromise<void> {
-    return this._client.post('/ingest/token', {
-      body,
-      ...options,
-      headers: { Accept: '*/*', ...options?.headers },
-    });
-  }
-
-  /**
-   * Validate your webhook is configured correctly.
-   */
-  validate(
-    body: IngestValidateParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<IngestValidateResponse> {
-    return this._client.post('/ingest/validate', { body, ...options });
-  }
-}
-
-export interface IngestValidateResponse {
-  code?: 200;
-
-  /**
-   * The return data for the tool request.
-   */
-  data?: string;
-}
-
-export interface IngestReturnWebhookParams {
-  /**
-   * The return data for the tool request.
-   */
-  data: unknown;
-}
-
-export interface IngestTokenParams {
-  /**
-   * The email of the user.
-   */
-  email: string;
-
-  /**
-   * The first name of the user.
-   */
-  firstName: string;
-
-  /**
-   * The last name of the user.
-   */
-  lastName: string;
-}
-
-export interface IngestValidateParams {
-  /**
-   * The return data for the tool request.
-   */
-  data: unknown;
-}
-
-export namespace Ingest {
-  export import IngestValidateResponse = IngestAPI.IngestValidateResponse;
-  export import IngestReturnWebhookParams = IngestAPI.IngestReturnWebhookParams;
-  export import IngestTokenParams = IngestAPI.IngestTokenParams;
-  export import IngestValidateParams = IngestAPI.IngestValidateParams;
 }