@lorikeetai/node-sdk 1.8.1 → 2.0.0

package/src/internal/utils/log.ts

@@ -0,0 +1,127 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { hasOwn } from './values';
+import { type Lorikeet } from '../../client';
+import { RequestOptions } from '../request-options';
+
+type LogFn = (message: string, ...rest: unknown[]) => void;
+export type Logger = {
+  error: LogFn;
+  warn: LogFn;
+  info: LogFn;
+  debug: LogFn;
+};
+export type LogLevel = 'off' | 'error' | 'warn' | 'info' | 'debug';
+
+const levelNumbers = {
+  off: 0,
+  error: 200,
+  warn: 300,
+  info: 400,
+  debug: 500,
+};
+
+export const parseLogLevel = (
+  maybeLevel: string | undefined,
+  sourceName: string,
+  client: Lorikeet,
+): LogLevel | undefined => {
+  if (!maybeLevel) {
+    return undefined;
+  }
+  if (hasOwn(levelNumbers, maybeLevel)) {
+    return maybeLevel;
+  }
+  loggerFor(client).warn(
+    `${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(
+      Object.keys(levelNumbers),
+    )}`,
+  );
+  return undefined;
+};
+
+function noop() {}
+
+function makeLogFn(fnLevel: keyof Logger, logger: Logger | undefined, logLevel: LogLevel) {
+  if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) {
+    return noop;
+  } else {
+    // Don't wrap logger functions, we want the stacktrace intact!
+    return logger[fnLevel].bind(logger);
+  }
+}
+
+const noopLogger = {
+  error: noop,
+  warn: noop,
+  info: noop,
+  debug: noop,
+};
+
+let cachedLoggers = /* @__PURE__ */ new WeakMap<Logger, [LogLevel, Logger]>();
+
+export function loggerFor(client: Lorikeet): Logger {
+  const logger = client.logger;
+  const logLevel = client.logLevel ?? 'off';
+  if (!logger) {
+    return noopLogger;
+  }
+
+  const cachedLogger = cachedLoggers.get(logger);
+  if (cachedLogger && cachedLogger[0] === logLevel) {
+    return cachedLogger[1];
+  }
+
+  const levelLogger = {
+    error: makeLogFn('error', logger, logLevel),
+    warn: makeLogFn('warn', logger, logLevel),
+    info: makeLogFn('info', logger, logLevel),
+    debug: makeLogFn('debug', logger, logLevel),
+  };
+
+  cachedLoggers.set(logger, [logLevel, levelLogger]);
+
+  return levelLogger;
+}
+
+export const formatRequestDetails = (details: {
+  options?: RequestOptions | undefined;
+  headers?: Headers | Record<string, string> | undefined;
+  retryOfRequestLogID?: string | undefined;
+  retryOf?: string | undefined;
+  url?: string | undefined;
+  status?: number | undefined;
+  method?: string | undefined;
+  durationMs?: number | undefined;
+  message?: unknown;
+  body?: unknown;
+}) => {
+  if (details.options) {
+    details.options = { ...details.options };
+    delete details.options['headers']; // redundant + leaks internals
+  }
+  if (details.headers) {
+    details.headers = Object.fromEntries(
+      (details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(
+        ([name, value]) => [
+          name,
+          (
+            name.toLowerCase() === 'authorization' ||
+            name.toLowerCase() === 'x-lorikeet-signature' ||
+            name.toLowerCase() === 'cookie' ||
+            name.toLowerCase() === 'set-cookie'
+          ) ?
+            '***'
+          : value,
+        ],
+      ),
+    );
+  }
+  if ('retryOfRequestLogID' in details) {
+    if (details.retryOfRequestLogID) {
+      details.retryOf = details.retryOfRequestLogID;
+    }
+    delete details.retryOfRequestLogID;
+  }
+  return details;
+};

package/src/internal/utils/path.ts

@@ -0,0 +1,88 @@
+import { LorikeetError } from '../../core/error';
+
+/**
+ * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
+ *
+ * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3:
+ * > unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * > sub-delims  = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ * > pchar       = unreserved / pct-encoded / sub-delims / ":" / "@"
+ */
+export function encodeURIPath(str: string) {
+  return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
+}
+
+const EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
+
+export const createPathTagFunction = (pathEncoder = encodeURIPath) =>
+  function path(statics: readonly string[], ...params: readonly unknown[]): string {
+    // If there are no params, no processing is needed.
+    if (statics.length === 1) return statics[0]!;
+
+    let postPath = false;
+    const invalidSegments = [];
+    const path = statics.reduce((previousValue, currentValue, index) => {
+      if (/[?#]/.test(currentValue)) {
+        postPath = true;
+      }
+      const value = params[index];
+      let encoded = (postPath ? encodeURIComponent : pathEncoder)('' + value);
+      if (
+        index !== params.length &&
+        (value == null ||
+          (typeof value === 'object' &&
+            // handle values from other realms
+            value.toString ===
+              Object.getPrototypeOf(Object.getPrototypeOf((value as any).hasOwnProperty ?? EMPTY) ?? EMPTY)
+                ?.toString))
+      ) {
+        encoded = value + '';
+        invalidSegments.push({
+          start: previousValue.length + currentValue.length,
+          length: encoded.length,
+          error: `Value of type ${Object.prototype.toString
+            .call(value)
+            .slice(8, -1)} is not a valid path parameter`,
+        });
+      }
+      return previousValue + currentValue + (index === params.length ? '' : encoded);
+    }, '');
+
+    const pathOnly = path.split(/[?#]/, 1)[0]!;
+    const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
+    let match;
+
+    // Find all invalid segments
+    while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
+      invalidSegments.push({
+        start: match.index,
+        length: match[0].length,
+        error: `Value "${match[0]}" can\'t be safely passed as a path parameter`,
+      });
+    }
+
+    invalidSegments.sort((a, b) => a.start - b.start);
+
+    if (invalidSegments.length > 0) {
+      let lastEnd = 0;
+      const underline = invalidSegments.reduce((acc, segment) => {
+        const spaces = ' '.repeat(segment.start - lastEnd);
+        const arrows = '^'.repeat(segment.length);
+        lastEnd = segment.start + segment.length;
+        return acc + spaces + arrows;
+      }, '');
+
+      throw new LorikeetError(
+        `Path parameters result in path with invalid segments:\n${invalidSegments
+          .map((e) => e.error)
+          .join('\n')}\n${path}\n${underline}`,
+      );
+    }
+
+    return path;
+  };
+
+/**
+ * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced.
+ */
+export const path = /* @__PURE__ */ createPathTagFunction(encodeURIPath);

package/src/internal/utils/sleep.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));

package/src/internal/utils/uuid.ts

@@ -0,0 +1,17 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+export let uuid4 = function () {
+  const { crypto } = globalThis as any;
+  if (crypto?.randomUUID) {
+    uuid4 = crypto.randomUUID.bind(crypto);
+    return crypto.randomUUID();
+  }
+  const u8 = new Uint8Array(1);
+  const randomByte = crypto ? () => crypto.getRandomValues(u8)[0]! : () => (Math.random() * 0xff) & 0xff;
+  return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) =>
+    (+c ^ (randomByte() & (15 >> (+c / 4)))).toString(16),
+  );
+};

package/src/internal/utils/values.ts

@@ -0,0 +1,105 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { LorikeetError } from '../../core/error';
+
+// https://url.spec.whatwg.org/#url-scheme-string
+const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+
+export const isAbsoluteURL = (url: string): boolean => {
+  return startsWithSchemeRegexp.test(url);
+};
+
+export let isArray = (val: unknown): val is unknown[] => ((isArray = Array.isArray), isArray(val));
+export let isReadonlyArray = isArray as (val: unknown) => val is readonly unknown[];
+
+/** Returns an object if the given value isn't an object, otherwise returns as-is */
+export function maybeObj(x: unknown): object {
+  if (typeof x !== 'object') {
+    return {};
+  }
+
+  return x ?? {};
+}
+
+// https://stackoverflow.com/a/34491287
+export function isEmptyObj(obj: Object | null | undefined): boolean {
+  if (!obj) return true;
+  for (const _k in obj) return false;
+  return true;
+}
+
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+export function hasOwn<T extends object = object>(obj: T, key: PropertyKey): key is keyof T {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+export function isObj(obj: unknown): obj is Record<string, unknown> {
+  return obj != null && typeof obj === 'object' && !Array.isArray(obj);
+}
+
+export const ensurePresent = <T>(value: T | null | undefined): T => {
+  if (value == null) {
+    throw new LorikeetError(`Expected a value to be given but received ${value} instead.`);
+  }
+
+  return value;
+};
+
+export const validatePositiveInteger = (name: string, n: unknown): number => {
+  if (typeof n !== 'number' || !Number.isInteger(n)) {
+    throw new LorikeetError(`${name} must be an integer`);
+  }
+  if (n < 0) {
+    throw new LorikeetError(`${name} must be a positive integer`);
+  }
+  return n;
+};
+
+export const coerceInteger = (value: unknown): number => {
+  if (typeof value === 'number') return Math.round(value);
+  if (typeof value === 'string') return parseInt(value, 10);
+
+  throw new LorikeetError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+
+export const coerceFloat = (value: unknown): number => {
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') return parseFloat(value);
+
+  throw new LorikeetError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+
+export const coerceBoolean = (value: unknown): boolean => {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') return value === 'true';
+  return Boolean(value);
+};
+
+export const maybeCoerceInteger = (value: unknown): number | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  return coerceInteger(value);
+};
+
+export const maybeCoerceFloat = (value: unknown): number | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  return coerceFloat(value);
+};
+
+export const maybeCoerceBoolean = (value: unknown): boolean | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  return coerceBoolean(value);
+};
+
+export const safeJSON = (text: string) => {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return undefined;
+  }
+};

package/src/internal/utils.ts

@@ -0,0 +1,8 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './utils/values';
+export * from './utils/base64';
+export * from './utils/env';
+export * from './utils/log';
+export * from './utils/uuid';
+export * from './utils/sleep';

package/src/lib/generate-signature.ts

@@ -1,11 +1,11 @@
-import { createHmac } from 'crypto';
+import { createHmac } from 'node:crypto';
 
 /**
  * Generate a signature for a given payload using a secret key.
  *
  * @param payload - The payload to sign - If no payload is provided, the signature will be generated for an empty string.
  */
-export function generateSignature(payload: Buffer | string | undefined, secret: string) {
+export function generateSignature(payload: Buffer | Uint8Array | string | undefined, secret: string) {
   if (!payload) {
     return createHmac('sha256', secret).digest('base64').replace(/\+/g, '-').replace(/\//g, '_');
   }

package/src/resource.ts

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

package/src/resources/api-keys.ts

@@ -1,7 +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 { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { buildHeaders } from '../internal/headers';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
 
 export class APIKeys extends APIResource {
   /**
@@ -13,7 +16,7 @@ export class APIKeys extends APIResource {
    * const apiKey = await client.apiKeys.create();
    * ```
    */
-  create(body: APIKeyCreateParams, options?: Core.RequestOptions): Core.APIPromise<APIKeyCreateResponse> {
+  create(body: APIKeyCreateParams, options?: RequestOptions): APIPromise<APIKeyCreateResponse> {
     return this._client.post('/v1/api-keys', { body, ...options });
   }
 
@@ -25,7 +28,7 @@ export class APIKeys extends APIResource {
    * const apiKeys = await client.apiKeys.list();
    * ```
    */
-  list(options?: Core.RequestOptions): Core.APIPromise<APIKeyListResponse> {
+  list(options?: RequestOptions): APIPromise<APIKeyListResponse> {
     return this._client.get('/v1/api-keys', options);
   }
 
@@ -39,10 +42,10 @@ export class APIKeys extends APIResource {
    * );
    * ```
    */
-  delete(id: string, options?: Core.RequestOptions): Core.APIPromise<void> {
-    return this._client.delete(`/v1/api-keys/${id}`, {
+  delete(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/v1/api-keys/${id}`, {
       ...options,
-      headers: { Accept: '*/*', ...options?.headers },
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
@@ -56,8 +59,8 @@ export class APIKeys extends APIResource {
    * );
    * ```
    */
-  get(id: string, options?: Core.RequestOptions): Core.APIPromise<APIKeyGetResponse> {
-    return this._client.get(`/v1/api-keys/${id}`, options);
+  get(id: string, options?: RequestOptions): APIPromise<APIKeyGetResponse> {
+    return this._client.get(path`/v1/api-keys/${id}`, options);
   }
 }
 

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.
+   * Send a message and poll until a response is ready.
    *
-   * When it return the response is the latest message type that is of type `BOT_RESPONSE`.
-   *
-   * @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
@@ -480,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,
@@ -489,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,
   };
 }