@lorikeetai/node-sdk 1.4.0 → 2.0.0

package/src/resources/conversation/chat.ts

@@ -1,28 +1,14 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../resource';
-import * as Core from '../../core';
-import { pollUntil } from "../../lib/poll-until";
+import { APIResource } from '../../core/resource';
 import * as ConversationAPI from './conversation';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { pollUntil } from '../../lib/poll-until';
+import { DeferredAsyncIterable } from '../../lib/promise';
 import { EventSource } from 'eventsource';
-import { DeferredAsyncIterable } from "../../lib/promise";
 
 export class Chat extends APIResource {
-  /**
-   * __chat.generate__
-   *
-   * Generate a chat message for a conversation. This endpoint will return immediately, polling will be required to get the response.
-   *
-   * The `latestMessageType` field in the response can be used to determine if the response is ready.
-   *
-   * If the `latestMessageType` is `BOT_RESPONSE`, the response is ready.
-   * For a more ergonomic way to poll, use the `message` method.
-   *
-   * ** WARNING ** This endpoint is not idempotent. If you call it multiple times, you will generate multiple messages.
-   *
-   * @see {@link Chat.message}
-   */
-
   /**
    * @example
    * ```ts
@@ -39,16 +25,10 @@ export class Chat extends APIResource {
    * });
    * ```
    */
-  generate(body: ChatGenerateParams, options?: Core.RequestOptions): Core.APIPromise<ChatGenerateResponse> {
+  generate(body: ChatGenerateParams, options?: RequestOptions): APIPromise<ChatGenerateResponse> {
     return this._client.post('/v1/conversation/chat/message', { body, ...options });
   }
 
-  /**
-   * __chat.get__
-   *
-   * Returns a chat message for a conversation. This endpoint will return the latest state of the conversation.
-   */
-
   /**
    * @example
    * ```ts
@@ -57,20 +37,10 @@ export class Chat extends APIResource {
    * });
    * ```
    */
-  get(query: ChatGetParams, options?: Core.RequestOptions): Core.APIPromise<ChatGetResponse> {
+  get(query: ChatGetParams, options?: RequestOptions): APIPromise<ChatGetResponse> {
     return this._client.get('/v1/conversation/chat/message', { query, ...options });
   }
 
-  /**
-   * __chat.start__
-   *
-   * Start a chat conversation. This endpoint will return immediately.
-   *
-   * The `conversationId` field in the response can be used to generate messages.
-   *
-   * ** WARNING ** This endpoint is not idempotent. If you call it multiple times, you will generate multiple conversations.
-   */
-
   /**
    * @example
    * ```ts
@@ -80,36 +50,34 @@ export class Chat extends APIResource {
    * });
    * ```
    */
-  start(body: ChatStartParams, options?: Core.RequestOptions): Core.APIPromise<ChatStartResponse> {
+  start(body: ChatStartParams, options?: RequestOptions): APIPromise<ChatStartResponse> {
     return this._client.post('/v1/conversation/chat/create', { body, ...options });
   }
 
   /**
-   * Returns a chat message for a conversation. This endpoint will poll until a response is ready.
-   *
-   * When it return the response is the latest message type that is of type `BOT_RESPONSE`.
+   * Send a message and poll until a response is ready.
    *
-   * @see {@link Chat.poll}
+   * This is a convenience wrapper that calls {@link Chat.generate} then {@link Chat.poll}.
    */
-  message(body: ChatGenerateParams, options?: Core.RequestOptions): Core.APIPromise<ChatGetResponse> {
+  message(body: ChatGenerateParams, options?: RequestOptions): APIPromise<ChatGetResponse> {
     return this.generate(body, options).then((response) =>
       this.poll({ conversationId: response.conversationId }, options),
-    ) as Core.APIPromise<ChatGetResponse>;
+    ) as APIPromise<ChatGetResponse>;
   }
 
   /**
-   * __chat.poll__
+   * Poll until the conversation has a bot response ready.
    *
-   * Polls until it returns a BOT chat message for a conversation.
+   * Stops when `latestMessageType` is `BOT_RESPONSE` or `PENDING_RESPONSE`,
+   * or when `status` is `Escalated` or `Error`.
    */
-  poll(query: ChatGetParams, options?: Core.RequestOptions): Core.APIPromise<ChatGetResponse> {
+  poll(query: ChatGetParams, options?: RequestOptions): APIPromise<ChatGetResponse> {
     return pollUntil<ChatGetResponse>(
       () => this._client.get('/v1/conversation/chat/message', { query, ...options }),
       {
         timeout: options?.timeout || 180_000,
         interval: 2_000,
         condition: (conversation) => {
-          // Don't poll if the conversation is escalated or in error
           if (conversation.status === 'Escalated' || conversation.status === 'Error') {
             return true;
           }
@@ -124,23 +92,18 @@ export class Chat extends APIResource {
           return false;
         },
       },
-    ) as Core.APIPromise<ChatGetResponse>;
+    ) as APIPromise<ChatGetResponse>;
   }
 
   /**
-   * __chat.streamUpdates__
-   *
    * Create a persistent stream of updates for a conversation.
-   * Responses from the bot will arrive as events. Consuming clients must aggregate multiple chunks
-   * into a single message based on the messageId field. Note that new messages may arrive without
-   * new user messages, this update stream is open indefinitely and does not automatically close - avoid
+   *
+   * Responses from the bot will arrive as events. Consuming clients must aggregate
+   * multiple chunks into a single message based on the `messageId` field.
+   *
+   * This stream is open indefinitely and does not automatically close — avoid
    * blocking other operations while listening to events from this generator.
    *
-   * @param params.conversationId - Conversation/ticket ID to subscribe to.
-   * @returns AsyncGenerator<ChatStreamEvent> a generator that emits response events as they arrive.
-   */
-
-  /**
    * @example
    * ```ts
    * for await (const evt of client.conversation.chat.streamUpdates({ conversationId: 'abc123' })) {
@@ -152,7 +115,7 @@ export class Chat extends APIResource {
     const queries = new URLSearchParams();
     queries.set('sseMessageTypes', 'new-message,message-chunk,message-complete');
     queries.set('ticketMessageTypes', 'BOT_RESPONSE');
-    const url = `/v1/ticket/sse/${params.conversationId}?${queries.toString()}`;
+    const url = `${this._client.baseURL}/v1/ticket/sse/${params.conversationId}?${queries.toString()}`;
     const eventSource = new EventSource(url);
     const output = new DeferredAsyncIterable<ChatStreamEvent>();
 
@@ -193,41 +156,6 @@ export class Chat extends APIResource {
   }
 }
 
-/**
- * Signal that a new response message has been created and new chunks
- * for this response for the messageId will follow.
- */
-export interface ChatStreamNewMessageEvent {
-  type: 'new-message';
-  // ISO 8601 timestamp of when the message was created
-  createdAt: string;
-  messageId: string;
-  // The initial content of the message, likely empty until the first chunk arrives
-  content: string;
-}
-
-/**
- * A chunk of text response for the message with the given messageId.
- */
-export interface ChatStreamMessageChunkEvent {
-  type: 'message-chunk';
-  contentDelta: string;
-  messageId: string;
-}
-
-/**
- * All chunks for a message have been received and no more chunks will follow for this message.
- */
-export interface ChatStreamMessageCompleteEvent {
-  type: 'message-complete';
-  messageId: string;
-}
-
-export type ChatStreamEvent =
-  | ChatStreamNewMessageEvent
-  | ChatStreamMessageChunkEvent
-  | ChatStreamMessageCompleteEvent;
-
 export interface ChatGenerateResponse {
   /**
    * The ID of the conversation
@@ -380,6 +308,11 @@ export interface ChatGenerateParams {
    * be omitted if the message is sent by the agent to the customer.
    */
   customer?: ChatGenerateParams.Customer;
+
+  /**
+   * The variables to be passed to the conversation - this can be used by workflows
+   */
+  variables?: { [key: string]: unknown };
 }
 
 export namespace ChatGenerateParams {
@@ -414,6 +347,11 @@ export namespace ChatGenerateParams {
      */
     lastName?: string;
 
+    /**
+     * The phone number of the customer (in international / E.164 format)
+     */
+    phoneNumber?: string;
+
     /**
      * The id of the customer in the ticketing system. For the SDK this needs to be
      * stable and unique
@@ -453,9 +391,14 @@ export interface ChatStartParams {
   publicKey: string;
 
   /**
-   * The timestamp of the when the conversation was created in our system.
+   * The subject of the conversation.
    */
   subject?: string;
+
+  /**
+   * The UUID of the workflow to trigger.
+   */
+  workflowId?: string;
 }
 
 export interface ChatStreamParams {
@@ -465,6 +408,39 @@ export interface ChatStreamParams {
   conversationId: string;
 }
 
+/**
+ * Signal that a new response message has been created and new chunks
+ * for this response for the messageId will follow.
+ */
+export interface ChatStreamNewMessageEvent {
+  type: 'new-message';
+  createdAt: string;
+  messageId: string;
+  content: string;
+}
+
+/**
+ * A chunk of text response for the message with the given messageId.
+ */
+export interface ChatStreamMessageChunkEvent {
+  type: 'message-chunk';
+  contentDelta: string;
+  messageId: string;
+}
+
+/**
+ * All chunks for a message have been received and no more chunks will follow for this message.
+ */
+export interface ChatStreamMessageCompleteEvent {
+  type: 'message-complete';
+  messageId: string;
+}
+
+export type ChatStreamEvent =
+  | ChatStreamNewMessageEvent
+  | ChatStreamMessageChunkEvent
+  | ChatStreamMessageCompleteEvent;
+
 export declare namespace Chat {
   export {
     type ChatGenerateResponse as ChatGenerateResponse,
@@ -474,5 +450,9 @@ export declare namespace Chat {
     type ChatGetParams as ChatGetParams,
     type ChatStartParams as ChatStartParams,
     type ChatStreamParams as ChatStreamParams,
+    type ChatStreamEvent as ChatStreamEvent,
+    type ChatStreamNewMessageEvent as ChatStreamNewMessageEvent,
+    type ChatStreamMessageChunkEvent as ChatStreamMessageChunkEvent,
+    type ChatStreamMessageCompleteEvent as ChatStreamMessageCompleteEvent,
   };
 }

package/src/resources/conversation/conversation.ts

@@ -1,7 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../resource';
-import * as Core from '../../core';
+import { APIResource } from '../../core/resource';
 import * as ChatAPI from './chat';
 import {
   Chat,
@@ -29,51 +28,6 @@ export class Conversation extends APIResource {
   email: EmailAPI.Email = new EmailAPI.Email(this._client);
   chat: ChatAPI.Chat = new ChatAPI.Chat(this._client);
   voice: VoiceAPI.Voice = new VoiceAPI.Voice(this._client);
-
-  /**
-   * @example
-   * ```ts
-   * const conversation = await client.conversation.create({
-   *   accountId: '1234567890',
-   *   phoneNumber: '0412745903',
-   *   'x-lorikeet-voice-public-key':
-   *     'x-lorikeet-voice-public-key',
-   * });
-   * ```
-   */
-  create(
-    params: ConversationCreateParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<ConversationCreateResponse> {
-    const { 'x-lorikeet-voice-public-key': xLorikeetVoicePublicKey, ...body } = params;
-    return this._client.post('/v1/conversation/new', {
-      body,
-      ...options,
-      headers: { 'x-lorikeet-voice-public-key': xLorikeetVoicePublicKey, ...options?.headers },
-    });
-  }
-
-  /**
-   * @example
-   * ```ts
-   * const response =
-   *   await client.conversation.retrieveTranscript('ticketId', {
-   *     'x-lorikeet-voice-public-key':
-   *       'x-lorikeet-voice-public-key',
-   *   });
-   * ```
-   */
-  retrieveTranscript(
-    ticketId: string,
-    params: ConversationRetrieveTranscriptParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<ConversationRetrieveTranscriptResponse> {
-    const { 'x-lorikeet-voice-public-key': xLorikeetVoicePublicKey } = params;
-    return this._client.get(`/v1/conversation/transcript/${ticketId}`, {
-      ...options,
-      headers: { 'x-lorikeet-voice-public-key': xLorikeetVoicePublicKey, ...options?.headers },
-    });
-  }
 }
 
 export interface AttachmentDto {
@@ -155,46 +109,6 @@ export interface TicketMessageDto {
   type: 'CUSTOMER' | 'BOT_RESPONSE' | 'PENDING_RESPONSE' | 'DRAFT_RESPONSE';
 }
 
-export interface ConversationCreateResponse {
-  /**
-   * The id of the ticket created
-   */
-  ticketId: string;
-}
-
-export interface ConversationRetrieveTranscriptResponse {
-  /**
-   * The custom attributes of the conversation
-   */
-  customAttributes: unknown;
-
-  /**
-   * The transcript of the conversation
-   */
-  transcript: string;
-}
-
-export interface ConversationCreateParams {
-  /**
-   * Body param: The id of the customer in the ticketing system
-   */
-  accountId: string;
-
-  /**
-   * Body param: The phone number of the customer
-   */
-  phoneNumber: string;
-
-  /**
-   * Header param:
-   */
-  'x-lorikeet-voice-public-key': string;
-}
-
-export interface ConversationRetrieveTranscriptParams {
-  'x-lorikeet-voice-public-key': string;
-}
-
 Conversation.Email = Email;
 Conversation.Chat = Chat;
 Conversation.Voice = Voice;
@@ -204,10 +118,6 @@ export declare namespace Conversation {
     type AttachmentDto as AttachmentDto,
     type TicketEvent as TicketEvent,
     type TicketMessageDto as TicketMessageDto,
-    type ConversationCreateResponse as ConversationCreateResponse,
-    type ConversationRetrieveTranscriptResponse as ConversationRetrieveTranscriptResponse,
-    type ConversationCreateParams as ConversationCreateParams,
-    type ConversationRetrieveTranscriptParams as ConversationRetrieveTranscriptParams,
   };
 
   export {

package/src/resources/conversation/email.ts

@@ -1,9 +1,10 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../resource';
-import * as Core from '../../core';
-import { pollUntil } from "../../lib/poll-until";
+import { APIResource } from '../../core/resource';
 import * as ConversationAPI from './conversation';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { pollUntil } from '../../lib/poll-until';
 
 export class Email extends APIResource {
   /**
@@ -22,7 +23,7 @@ export class Email extends APIResource {
    * });
    * ```
    */
-  generate(body: EmailGenerateParams, options?: Core.RequestOptions): Core.APIPromise<EmailGenerateResponse> {
+  generate(body: EmailGenerateParams, options?: RequestOptions): APIPromise<EmailGenerateResponse> {
     return this._client.post('/v1/conversation/email/message', { body, ...options });
   }
 
@@ -34,7 +35,7 @@ export class Email extends APIResource {
    * });
    * ```
    */
-  get(query: EmailGetParams, options?: Core.RequestOptions): Core.APIPromise<EmailGetResponse> {
+  get(query: EmailGetParams, options?: RequestOptions): APIPromise<EmailGetResponse> {
     return this._client.get('/v1/conversation/email/message', { query, ...options });
   }
 
@@ -47,23 +48,23 @@ export class Email extends APIResource {
    * });
    * ```
    */
-  start(body: EmailStartParams, options?: Core.RequestOptions): Core.APIPromise<EmailStartResponse> {
+  start(body: EmailStartParams, options?: RequestOptions): APIPromise<EmailStartResponse> {
     return this._client.post('/v1/conversation/email/create', { body, ...options });
   }
 
   /**
-   * __chat.get__
+   * Poll until the conversation has a bot response ready.
    *
-   * Polls until it returns a BOT chat message for a conversation.
+   * Stops when `latestMessageType` is `BOT_RESPONSE` or `PENDING_RESPONSE`,
+   * or when `status` is `Escalated` or `Error`.
    */
-  poll(query: EmailGetParams, options?: Core.RequestOptions): Core.APIPromise<EmailGetResponse> {
+  poll(query: EmailGetParams, options?: RequestOptions): APIPromise<EmailGetResponse> {
     return pollUntil<EmailGetResponse>(
-      () => this._client.get('/v1/conversation/chat/message', { query, ...options }),
+      () => this._client.get('/v1/conversation/email/message', { query, ...options }),
       {
         timeout: options?.timeout || 180_000,
         interval: 2_000,
         condition: (conversation) => {
-          // Don't poll if the conversation is escalated or in error
           if (conversation.status === 'Escalated' || conversation.status === 'Error') {
             return true;
           }
@@ -78,7 +79,7 @@ export class Email extends APIResource {
           return false;
         },
       },
-    ) as Core.APIPromise<EmailGetResponse>;
+    ) as APIPromise<EmailGetResponse>;
   }
 }
 
@@ -234,6 +235,11 @@ export interface EmailGenerateParams {
    * be omitted if the message is sent by the agent to the customer.
    */
   customer?: EmailGenerateParams.Customer;
+
+  /**
+   * The variables to be passed to the conversation - this can be used by workflows
+   */
+  variables?: { [key: string]: unknown };
 }
 
 export namespace EmailGenerateParams {
@@ -268,6 +274,11 @@ export namespace EmailGenerateParams {
      */
     lastName?: string;
 
+    /**
+     * The phone number of the customer (in international / E.164 format)
+     */
+    phoneNumber?: string;
+
     /**
      * The id of the customer in the ticketing system. For the SDK this needs to be
      * stable and unique
@@ -307,9 +318,14 @@ export interface EmailStartParams {
   publicKey: string;
 
   /**
-   * The timestamp of the when the conversation was created in our system.
+   * The subject of the conversation.
    */
   subject?: string;
+
+  /**
+   * The UUID of the workflow to trigger.
+   */
+  workflowId?: string;
 }
 
 export declare namespace Email {

package/src/resources/conversation/index.ts

@@ -8,17 +8,13 @@ export {
   type ChatGenerateParams,
   type ChatGetParams,
   type ChatStartParams,
+  type ChatStreamParams,
+  type ChatStreamEvent,
+  type ChatStreamNewMessageEvent,
+  type ChatStreamMessageChunkEvent,
+  type ChatStreamMessageCompleteEvent,
 } from './chat';
-export {
-  Conversation,
-  type AttachmentDto,
-  type TicketEvent,
-  type TicketMessageDto,
-  type ConversationCreateResponse,
-  type ConversationRetrieveTranscriptResponse,
-  type ConversationCreateParams,
-  type ConversationRetrieveTranscriptParams,
-} from './conversation';
+export { Conversation, type AttachmentDto, type TicketEvent, type TicketMessageDto } from './conversation';
 export {
   Email,
   type EmailGenerateResponse,

package/src/resources/conversation/voice.ts

@@ -1,7 +1,9 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../resource';
-import * as Core from '../../core';
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { buildHeaders } from '../../internal/headers';
+import { RequestOptions } from '../../internal/request-options';
 
 export class Voice extends APIResource {
   /**
@@ -12,11 +14,11 @@ export class Voice extends APIResource {
    * });
    * ```
    */
-  outbound(body: VoiceOutboundParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+  outbound(body: VoiceOutboundParams, options?: RequestOptions): APIPromise<void> {
     return this._client.post('/v1/conversation/voice/outbound', {
       body,
       ...options,
-      headers: { Accept: '*/*', ...options?.headers },
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 }
@@ -41,7 +43,9 @@ export interface VoiceOutboundParams {
   customerId?: string;
 
   /**
-   * The input data to pass to the workflow. Only used if a workflow is specified.
+   * Input data to pass to workflows. Should include values for input fields defined
+   * by both the chosen opening workflow and - if configured - the voicemail detected
+   * workflow.
    */
   inputData?: unknown;