@holocronlab/botruntime-chat 0.5.5

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2023 Botpress Technologies, Inc.
+Portions Copyright (c) 2026 HolocronLab.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# @holocronlab/botruntime-chat
+
+Chat API client consumed by the `brt` CLI to power `brt chat` (an interactive
+terminal chat session against a bot's Chat integration webhook).
+
+## Provenance
+
+This package vendors the published npm **dist** of `@botpress/chat@0.5.5`
+verbatim (`dist/index.cjs`, `dist/index.mjs`, `dist/index.d.ts`, and the
+generated `.d.ts` files under `dist/gen`). It is a fork of Botpress
+Technologies, Inc.'s MIT-licensed `@botpress/chat` package — see `LICENSE`.
+
+The upstream package's *source* is codegenerated from an OpenAPI spec via a
+`chat-api` codegen chain that is not published to npm. Because `@botpress/chat`
+is not the byte-exact oracle crux for this fork (that role belongs to
+`@botpress/client`), vendoring its dist is the deliberate Phase-2 choice here.
+A source-level fork (owning the codegen chain / OpenAPI spec, analogous to
+`@botpress/client`'s ADR-0005 migration) is deferred to that same
+openapi -> owned-source migration effort.
+
+No source changes were made to the vendored dist — this package only renames
+the npm package identity (`name`, `repository`) so it can be published
+independently under the `@holocronlab` scope. The runtime behavior, wire
+contract (HTTP paths, headers), and public API surface are unchanged from
+`@botpress/chat@0.5.5`.
+
+## Installation
+
+```bash
+npm install @holocronlab/botruntime-chat
+```
+
+## Usage
+
+```ts
+import * as chat from '@holocronlab/botruntime-chat'
+
+const client = await chat.Client.connect({ webhookId: process.env.WEBHOOK_ID! })
+
+const { conversation } = await client.createConversation({})
+await client.createMessage({
+  conversationId: conversation.id,
+  payload: { type: 'text', text: 'hello world' },
+})
+
+const listener = await client.listenConversation({ id: conversation.id })
+listener.on('message_created', (message: chat.Signals['message_created']) => {
+  console.log(message.payload)
+})
+```
+
+See upstream `@botpress/chat` documentation for the full API (conversations,
+messages, participants, users, events, realtime listening via SSE/websocket).
+
+## Dependencies
+
+Runtime dependencies are unchanged from upstream: `axios`, `browser-or-node`,
+`event-source-polyfill`, `eventsource`, `jsonwebtoken`, `qs`, `verror`, `zod`.
+Zero `@botpress/*` or `@bpinternal/*` runtime dependencies.
+
+## License
+
+MIT (see `LICENSE`). Derived from Botpress Technologies, Inc.'s
+`@botpress/chat` package.

package/dist/client.d.ts

@@ -0,0 +1,363 @@
+import { AsyncCollection } from './listing';
+import { SignalListener } from './signal-listener';
+import * as types from './types';
+declare const _createAuthClient: unique symbol;
+type Merge<A, B> = Omit<A, keyof B> & B;
+type IClient = Merge<{
+    [K in types.ClientOperation]: (x: types.ClientRequests[K]) => Promise<types.ClientResponses[K]>;
+}, {
+    listenConversation: (args: types.ClientRequests['listenConversation']) => Promise<SignalListener>;
+}>;
+type IAuthenticatedClient = Merge<{
+    [K in types.AuthenticatedOperation]: (x: types.AuthenticatedClientRequests[K]) => Promise<types.ClientResponses[K]>;
+}, {
+    listenConversation: (args: types.AuthenticatedClientRequests['listenConversation']) => Promise<SignalListener>;
+}>;
+export declare class Client implements IClient {
+    readonly props: Readonly<types.ClientProps>;
+    private _connectionTested;
+    private _auto;
+    constructor(props: Readonly<types.ClientProps>);
+    get apiVersion(): string;
+    /**
+     * Gets or creates a user based on the provided props and returns an authenticated client.
+     */
+    static connect(props: types.ConnectProps): Promise<AuthenticatedClient>;
+    readonly createConversation: IClient['createConversation'];
+    readonly getConversation: IClient['getConversation'];
+    readonly getOrCreateConversation: IClient['getOrCreateConversation'];
+    readonly deleteConversation: IClient['deleteConversation'];
+    readonly listConversations: IClient['listConversations'];
+    readonly listMessages: IClient['listMessages'];
+    readonly addParticipant: IClient['addParticipant'];
+    readonly removeParticipant: IClient['removeParticipant'];
+    readonly getParticipant: IClient['getParticipant'];
+    readonly listParticipants: IClient['listParticipants'];
+    readonly createMessage: IClient['createMessage'];
+    readonly getMessage: IClient['getMessage'];
+    readonly deleteMessage: IClient['deleteMessage'];
+    readonly createUser: IClient['createUser'];
+    readonly getUser: IClient['getUser'];
+    readonly getOrCreateUser: IClient['getOrCreateUser'];
+    readonly updateUser: IClient['updateUser'];
+    readonly deleteUser: IClient['deleteUser'];
+    readonly createEvent: IClient['createEvent'];
+    readonly getEvent: IClient['getEvent'];
+    get list(): {
+        conversations: (props: types.ClientRequests["listConversations"]) => AsyncCollection<{
+            id: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+        messages: (props: types.ClientRequests["listMessages"]) => AsyncCollection<{
+            id: string;
+            createdAt: string;
+            payload: {
+                [x: string]: any;
+                type: "audio";
+                audioUrl: string;
+            } | {
+                [x: string]: any;
+                type: "card";
+                title: string;
+                subtitle?: string | undefined;
+                imageUrl?: string | undefined;
+                actions: {
+                    [x: string]: any;
+                    action: "postback" | "url" | "say";
+                    label: string;
+                    value: string;
+                }[];
+            } | {
+                [x: string]: any;
+                type: "carousel";
+                items: {
+                    [x: string]: any;
+                    type: "card";
+                    title: string;
+                    subtitle?: string | undefined;
+                    imageUrl?: string | undefined;
+                    actions: {
+                        [x: string]: any;
+                        action: "postback" | "url" | "say";
+                        label: string;
+                        value: string;
+                    }[];
+                }[];
+            } | {
+                [x: string]: any;
+                text: string;
+                options: {
+                    [x: string]: any;
+                    label: string;
+                    value: string;
+                }[];
+                type: "choice";
+            } | {
+                [x: string]: any;
+                text: string;
+                options: {
+                    [x: string]: any;
+                    label: string;
+                    value: string;
+                }[];
+                type: "dropdown";
+            } | {
+                [x: string]: any;
+                type: "file";
+                fileUrl: string;
+                title?: string | undefined;
+            } | {
+                [x: string]: any;
+                type: "image";
+                imageUrl: string;
+            } | {
+                [x: string]: any;
+                type: "location";
+                latitude: number;
+                longitude: number;
+                address?: string | undefined;
+                title?: string | undefined;
+            } | {
+                [x: string]: any;
+                type: "text";
+                text: string;
+            } | {
+                [x: string]: any;
+                type: "video";
+                videoUrl: string;
+            } | {
+                [x: string]: any;
+                type: "markdown";
+                markdown: string;
+            } | {
+                [x: string]: any;
+                type: "bloc";
+                items: ({
+                    [x: string]: any;
+                    type: "text";
+                    text: string;
+                } | {
+                    [x: string]: any;
+                    type: "markdown";
+                    markdown: string;
+                } | {
+                    [x: string]: any;
+                    type: "image";
+                    imageUrl: string;
+                } | {
+                    [x: string]: any;
+                    type: "audio";
+                    audioUrl: string;
+                } | {
+                    [x: string]: any;
+                    type: "video";
+                    videoUrl: string;
+                } | {
+                    [x: string]: any;
+                    type: "file";
+                    fileUrl: string;
+                    title?: string | undefined;
+                } | {
+                    [x: string]: any;
+                    type: "location";
+                    latitude: number;
+                    longitude: number;
+                    address?: string | undefined;
+                    title?: string | undefined;
+                })[];
+            };
+            userId: string;
+            conversationId: string;
+            metadata?: {
+                [x: string]: any;
+            } | undefined;
+        }>;
+        participants: (props: types.ClientRequests["listParticipants"]) => AsyncCollection<{
+            id: string;
+            name?: string | undefined;
+            pictureUrl?: string | undefined;
+            profile?: string | undefined;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+    readonly listenConversation: IClient['listenConversation'];
+    private _call;
+    /**
+     * The Chat-API is called like any other integrations by sending requests to the bridge webhook endpoint.
+     * This endpoint may return a successful status code even when the payload contains an error.
+     * This method parses the payload to check for an error and throws an error if one is found.
+     */
+    private _checkPayloadForError;
+    private static _createAxios;
+    private get _apiUrl();
+    private static _getApiUrl;
+    private _testConnection;
+}
+export declare class AuthenticatedClient implements IAuthenticatedClient {
+    private _client;
+    readonly user: types.AuthenticatedUser;
+    private constructor();
+    static [_createAuthClient]: (client: Client, user: types.AuthenticatedUser) => AuthenticatedClient;
+    get apiVersion(): string;
+    readonly createConversation: IAuthenticatedClient['createConversation'];
+    readonly getConversation: IAuthenticatedClient['getConversation'];
+    readonly getOrCreateConversation: IAuthenticatedClient['getOrCreateConversation'];
+    readonly deleteConversation: IAuthenticatedClient['deleteConversation'];
+    readonly listConversations: IAuthenticatedClient['listConversations'];
+    readonly listMessages: IAuthenticatedClient['listMessages'];
+    readonly listenConversation: IAuthenticatedClient['listenConversation'];
+    readonly addParticipant: IAuthenticatedClient['addParticipant'];
+    readonly removeParticipant: IAuthenticatedClient['removeParticipant'];
+    readonly getParticipant: IAuthenticatedClient['getParticipant'];
+    readonly listParticipants: IAuthenticatedClient['listParticipants'];
+    readonly createMessage: IAuthenticatedClient['createMessage'];
+    readonly getMessage: IAuthenticatedClient['getMessage'];
+    readonly deleteMessage: IAuthenticatedClient['deleteMessage'];
+    readonly getUser: IAuthenticatedClient['getUser'];
+    readonly updateUser: IAuthenticatedClient['updateUser'];
+    readonly deleteUser: IAuthenticatedClient['deleteUser'];
+    readonly createEvent: IAuthenticatedClient['createEvent'];
+    readonly getEvent: IAuthenticatedClient['getEvent'];
+    get list(): {
+        conversations: (x: types.AuthenticatedClientRequests["listConversations"]) => AsyncCollection<{
+            id: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+        messages: (x: types.AuthenticatedClientRequests["listMessages"]) => AsyncCollection<{
+            id: string;
+            createdAt: string;
+            payload: {
+                [x: string]: any;
+                type: "audio";
+                audioUrl: string;
+            } | {
+                [x: string]: any;
+                type: "card";
+                title: string;
+                subtitle?: string | undefined;
+                imageUrl?: string | undefined;
+                actions: {
+                    [x: string]: any;
+                    action: "postback" | "url" | "say";
+                    label: string;
+                    value: string;
+                }[];
+            } | {
+                [x: string]: any;
+                type: "carousel";
+                items: {
+                    [x: string]: any;
+                    type: "card";
+                    title: string;
+                    subtitle?: string | undefined;
+                    imageUrl?: string | undefined;
+                    actions: {
+                        [x: string]: any;
+                        action: "postback" | "url" | "say";
+                        label: string;
+                        value: string;
+                    }[];
+                }[];
+            } | {
+                [x: string]: any;
+                text: string;
+                options: {
+                    [x: string]: any;
+                    label: string;
+                    value: string;
+                }[];
+                type: "choice";
+            } | {
+                [x: string]: any;
+                text: string;
+                options: {
+                    [x: string]: any;
+                    label: string;
+                    value: string;
+                }[];
+                type: "dropdown";
+            } | {
+                [x: string]: any;
+                type: "file";
+                fileUrl: string;
+                title?: string | undefined;
+            } | {
+                [x: string]: any;
+                type: "image";
+                imageUrl: string;
+            } | {
+                [x: string]: any;
+                type: "location";
+                latitude: number;
+                longitude: number;
+                address?: string | undefined;
+                title?: string | undefined;
+            } | {
+                [x: string]: any;
+                type: "text";
+                text: string;
+            } | {
+                [x: string]: any;
+                type: "video";
+                videoUrl: string;
+            } | {
+                [x: string]: any;
+                type: "markdown";
+                markdown: string;
+            } | {
+                [x: string]: any;
+                type: "bloc";
+                items: ({
+                    [x: string]: any;
+                    type: "text";
+                    text: string;
+                } | {
+                    [x: string]: any;
+                    type: "markdown";
+                    markdown: string;
+                } | {
+                    [x: string]: any;
+                    type: "image";
+                    imageUrl: string;
+                } | {
+                    [x: string]: any;
+                    type: "audio";
+                    audioUrl: string;
+                } | {
+                    [x: string]: any;
+                    type: "video";
+                    videoUrl: string;
+                } | {
+                    [x: string]: any;
+                    type: "file";
+                    fileUrl: string;
+                    title?: string | undefined;
+                } | {
+                    [x: string]: any;
+                    type: "location";
+                    latitude: number;
+                    longitude: number;
+                    address?: string | undefined;
+                    title?: string | undefined;
+                })[];
+            };
+            userId: string;
+            conversationId: string;
+            metadata?: {
+                [x: string]: any;
+            } | undefined;
+        }>;
+        participants: (x: types.AuthenticatedClientRequests["listParticipants"]) => AsyncCollection<{
+            id: string;
+            name?: string | undefined;
+            pictureUrl?: string | undefined;
+            profile?: string | undefined;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+}
+export {};

package/dist/consts.d.ts

@@ -0,0 +1 @@
+export declare const defaultBaseApiUrl = "https://botruntime.ru";

package/dist/errors.d.ts

@@ -0,0 +1,20 @@
+import { AxiosError } from 'axios';
+import { VError } from 'verror';
+export * from './gen/client/errors';
+export declare class ChatClientError extends VError {
+    static wrap(thrown: unknown, message: string): ChatClientError;
+    static map(thrown: unknown): ChatClientError;
+    constructor(error: ChatClientError, message: string);
+    constructor(message: string);
+}
+export declare class ChatHTTPError extends ChatClientError {
+    readonly status: number | undefined;
+    constructor(status: number | undefined, message: string);
+    static fromAxios(e: AxiosError<{
+        message?: string;
+    }>): ChatHTTPError;
+    private static _axiosMsg;
+}
+export declare class ChatConfigError extends ChatClientError {
+    constructor(message: string);
+}

package/dist/event-emitter.d.ts

@@ -0,0 +1,10 @@
+export type ListenStatus = 'keep-listening' | 'stop-listening';
+export declare class EventEmitter<E extends object> {
+    private _listeners;
+    emit<K extends keyof E>(type: K, event: E[K]): void;
+    onceOrMore<K extends keyof E>(type: K, listener: (event: E[K]) => ListenStatus): void;
+    once<K extends keyof E>(type: K, listener: (event: E[K]) => void): void;
+    on<K extends keyof E>(type: K, listener: (event: E[K]) => void): void;
+    off<K extends keyof E>(type: K, listener: (event: E[K]) => void): void;
+    cleanup(): void;
+}

package/dist/eventsource.d.ts

@@ -0,0 +1,32 @@
+import type EventSourceBrowser from 'event-source-polyfill';
+import type EventSourceNodeJs from 'eventsource';
+import { EventEmitter } from './event-emitter';
+type NodeOnOpen = EventSourceNodeJs['onopen'];
+type NodeOnMessage = EventSourceNodeJs['onmessage'];
+type NodeOnError = EventSourceNodeJs['onerror'];
+type NodeOpenEvent = Parameters<NodeOnOpen>[0];
+type NodeMessageEvent = Parameters<NodeOnMessage>[0];
+type NodeErrorEvent = Parameters<NodeOnError>[0];
+type BrowserOnOpen = NonNullable<EventSourceBrowser.EventSourcePolyfill['onopen']>;
+type BrowserOnMessage = NonNullable<EventSourceBrowser.EventSourcePolyfill['onmessage']>;
+type BrowserOnError = NonNullable<EventSourceBrowser.EventSourcePolyfill['onerror']>;
+type BrowserOpenEvent = Parameters<BrowserOnOpen>[0];
+type BrowserMessageEvent = Parameters<BrowserOnMessage>[0];
+type BrowserErrorEvent = Parameters<BrowserOnError>[0];
+export type OpenEvent = NodeOpenEvent | BrowserOpenEvent;
+export type MessageEvent = NodeMessageEvent | BrowserMessageEvent;
+export type ErrorEvent = NodeErrorEvent | BrowserErrorEvent;
+export type Events = {
+    open: OpenEvent;
+    message: MessageEvent;
+    error: ErrorEvent;
+};
+export type Props = {
+    headers?: Record<string, string>;
+};
+export type EventSourceEmitter = {
+    on: EventEmitter<Events>['on'];
+    close: () => void;
+};
+export declare const listenEventSource: (url: string, props?: Props) => Promise<EventSourceEmitter>;
+export {};