@bayonai/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BayonAI
+
+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,19 @@
+# @bayonai/sdk
+
+TypeScript SDK for the BayonAI Firebase API.
+
+```ts
+import { createBayonAiClient } from "@bayonai/sdk";
+
+const bayonai = createBayonAiClient({
+  baseUrl: "https://api-q2ifyofooa-uc.a.run.app/api",
+  apiKey: process.env.BAYONAI_API_KEY,
+});
+
+const response = await bayonai.conversations.send({
+  personaId: "journalapp",
+  messages: [{ role: "user", content: "TEST" }],
+});
+```
+
+The SDK keeps the API's chat contract intact: `messages` is sent to BayonAI as a stringified JSON array.

package/dist/index.cjs

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BayonAiError = void 0;
+exports.createBayonAiClient = createBayonAiClient;
+class BayonAiError extends Error {
+    details;
+    endpoint;
+    kind;
+    status;
+    constructor({ details, endpoint, kind, message, status, }) {
+        super(message);
+        this.name = "BayonAiError";
+        this.details = details;
+        this.endpoint = endpoint;
+        this.kind = kind;
+        this.status = status;
+    }
+}
+exports.BayonAiError = BayonAiError;
+function createBayonAiClient(config) {
+    const transport = createTransport(config);
+    return {
+        a2a: {
+            agentCard: (personaId, options) => transport(`/agent/card/${encodePathPart(personaId)}`, {
+                method: "GET",
+                options,
+            }),
+        },
+        admin: {
+            contacts: {
+                send: (body, options) => post(transport, "/admin/contacts", body, options),
+            },
+            conversations: {
+                all: (body, options) => post(transport, "/admin/convo/all", body, options),
+            },
+            interfaces: {
+                add: (body, options) => post(transport, "/admin/interfaces/add", body, options),
+                all: (body, options) => post(transport, "/admin/interfaces/all", body, options),
+                delete: (body, options) => post(transport, "/admin/interfaces/delete", body, options),
+                update: (body, options) => post(transport, "/admin/interfaces/update", body, options),
+            },
+            organizations: {
+                all: (body = {}, options) => post(transport, "/admin/org/all", body, options),
+                customMany: (body, options) => post(transport, "/admin/org/custom/many", body, options),
+                customSet: (body, options) => post(transport, "/admin/org/custom/set", body, options),
+                mine: (body = {}, options) => post(transport, "/admin/org/mine", body, options),
+                role: (body = {}, options) => post(transport, "/admin/org/role", body, options),
+            },
+            personas: {
+                createOrUpdate: (body, options) => post(transport, "/admin/personas", body, options),
+                get: (body, options) => post(transport, "/admin/personas/get", body, options),
+                set: (body, options) => post(transport, "/admin/personas/set", body, options),
+                systemPrompt: (body, options) => post(transport, "/admin/personas/sys_prompt", body, options),
+            },
+            stats: {
+                events: (body, options) => post(transport, "/admin/stats/events", body, options),
+                requests: (body, options) => post(transport, "/admin/stats/requests", body, options),
+            },
+            tracking: {
+                consumption: (body, options) => post(transport, "/admin/tracking/consumption", body, options),
+                events: (body, options) => post(transport, "/admin/tracking/events", body, options),
+                requests: (body, options) => post(transport, "/admin/tracking/requests", body, options),
+                usage: (body, options) => post(transport, "/admin/tracking/usage", body, options),
+            },
+            users: {
+                all: (body, options) => post(transport, "/admin/users/all", body, options),
+                current: (body = {}, options) => post(transport, "/admin/users/current", body, options),
+                get: (body, options) => post(transport, "/admin/users/get", body, options),
+                stats: (body, options) => post(transport, "/admin/users/stats", body, options),
+            },
+        },
+        agents: {
+            assigned: (body = {}, options) => post(transport, "/agents/assigned", body, options),
+            get: (id, options) => transport("/agents/get", {
+                method: "GET",
+                options,
+                query: { id },
+            }),
+            getPost: (id, options) => post(transport, "/agents/get", { id }, options),
+        },
+        conversations: {
+            all: (body = {}, options) => post(transport, "/convo/all", body, options),
+            close: (convoId, options) => post(transport, "/convo/close", { convoId }, options),
+            last: (body, options) => post(transport, "/convo/last", body, options),
+            own: (convoId, options) => post(transport, "/convo/own", { convoId }, options),
+            send: (body, options) => post(transport, "/convo/send", {
+                ...omitUndefined(body),
+                messages: JSON.stringify(body.messages),
+            }, options),
+            star: (convoId, star, options) => post(transport, "/convo/star", { convoId, star }, options),
+            summary: (convoId, options) => post(transport, "/convo/summary", { convoId }, options),
+            title: (convoId, options) => post(transport, "/convo/title", { convoId }, options),
+            setTitle: (convoId, title, options) => post(transport, "/convo/title/set", { convoId, title }, options),
+        },
+        externalAuth: {
+            createToken: (body, options) => post(transport, "/external/auth/token", body, options),
+        },
+        externalUsers: {
+            me: (options) => transport("/external/users/me", { method: "GET", options }),
+        },
+        feedback: {
+            submit: (body, options) => post(transport, "/feedback", body, options),
+        },
+        platform: {
+            const: {
+                get: (name, options) => transport(`/const/${encodePathPart(name)}`, {
+                    method: "GET",
+                    options,
+                }),
+            },
+            data: {
+                reload: (body = {}, options) => post(transport, "/data/reload", body, options),
+            },
+            log: {
+                write: (body = {}, options) => post(transport, "/log", body, options),
+            },
+            messenger: {
+                receive: (body, options) => post(transport, "/messenger/receive", body, options),
+                send: (body, options) => post(transport, "/messenger/send", body, options),
+                webhook: (query = {}, options) => transport("/messenger/webhook", {
+                    method: "GET",
+                    options,
+                    query,
+                }),
+            },
+            respondIo: {
+                convoClosed: (orgId, body, options) => post(transport, `/respondio/${encodePathPart(orgId)}/convo_closed`, body, options),
+                convoOpened: (orgId, body, options) => post(transport, `/respondio/${encodePathPart(orgId)}/convo_opened`, body, options),
+                log: (orgId, body = {}, options) => post(transport, `/respondio/${encodePathPart(orgId)}/log`, body, options),
+                messageReceived: (orgId, body, options) => post(transport, `/respondio/${encodePathPart(orgId)}/message_received`, body, options),
+                messageSent: (orgId, body, options) => post(transport, `/respondio/${encodePathPart(orgId)}/message_sent`, body, options),
+            },
+            twilio: {
+                receive: (body, options) => post(transport, "/twilio/receive", body, options),
+                send: (query = {}, options) => transport("/twilio/send", { method: "GET", options, query }),
+            },
+            whatsapp: {
+                send: (body, options) => post(transport, "/whatsapp/send", body, options),
+                subscribe: (query = {}, options) => transport("/whatsapp/subscribe", {
+                    method: "GET",
+                    options,
+                    query,
+                }),
+                webhook: (body, options) => post(transport, "/whatsapp/webhook", body, options),
+            },
+        },
+        raw: {
+            get: (path, query, options) => transport(path, { method: "GET", options, query }),
+            post: (path, body, options) => transport(path, { body, method: "POST", options }),
+        },
+        stats: {
+            current: (query = {}, options) => transport("/stats", { method: "GET", options, query }),
+            events: (body, options) => post(transport, "/stats/events", body, options),
+        },
+        subscriptions: {
+            extend: (body, options) => post(transport, "/subscriptions/extend", body, options),
+            level: (body, options) => post(transport, "/subscriptions/level", body, options),
+        },
+    };
+}
+function createTransport(config) {
+    return async function request(endpoint, { body, method = "POST", options, query } = {}) {
+        const fetchImpl = config.fetch ?? globalThis.fetch;
+        if (!fetchImpl) {
+            throw new BayonAiError({
+                endpoint,
+                kind: "config",
+                message: "A fetch implementation is required.",
+            });
+        }
+        const url = buildUrl(config.baseUrl, endpoint, query);
+        let response;
+        try {
+            response = await fetchImpl(url, {
+                method,
+                headers: buildHeaders(config, options, body !== undefined),
+                ...(body === undefined ? {} : { body: JSON.stringify(omitUndefined(body)) }),
+            });
+        }
+        catch (error) {
+            throw new BayonAiError({
+                details: sanitizeDetails(error),
+                endpoint,
+                kind: "network",
+                message: `BayonAI request failed for ${endpoint}.`,
+            });
+        }
+        const data = await readResponseJson(response, endpoint);
+        if (!response.ok) {
+            throw new BayonAiError({
+                details: sanitizeDetails(data),
+                endpoint,
+                kind: "http",
+                message: `BayonAI request failed with HTTP ${response.status}.`,
+                status: response.status,
+            });
+        }
+        return data;
+    };
+}
+function post(transport, endpoint, body, options) {
+    return transport(endpoint, { body, method: "POST", options });
+}
+function buildHeaders(config, options, hasBody) {
+    const headers = {
+        ...(hasBody ? { "Content-Type": "application/json" } : {}),
+        ...(options?.headers ?? {}),
+    };
+    if (options?.bearerToken) {
+        headers.Authorization = `Bearer ${options.bearerToken}`;
+        return headers;
+    }
+    const apiKey = options?.apiKey ?? config.apiKey;
+    if (apiKey) {
+        headers["x-api-key"] = apiKey;
+    }
+    return headers;
+}
+function buildUrl(baseUrl, endpoint, query) {
+    const normalizedBase = baseUrl.replace(/\/+$/, "");
+    const normalizedEndpoint = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+    const url = new URL(`${normalizedBase}${normalizedEndpoint}`);
+    Object.entries(query ?? {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            url.searchParams.set(key, String(value));
+        }
+    });
+    return url.toString();
+}
+function encodePathPart(value) {
+    return encodeURIComponent(value);
+}
+async function readResponseJson(response, endpoint) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.includes("application/json")) {
+        if (response.ok) {
+            return response.text();
+        }
+        return null;
+    }
+    try {
+        return await response.json();
+    }
+    catch (error) {
+        throw new BayonAiError({
+            details: sanitizeDetails(error),
+            endpoint,
+            kind: "parse",
+            message: `BayonAI returned invalid JSON for ${endpoint}.`,
+            status: response.status,
+        });
+    }
+}
+function omitUndefined(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== undefined));
+}
+function sanitizeDetails(value) {
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    if (value instanceof Error) {
+        return { message: value.message };
+    }
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !/(key|token|authorization|secret|password)/i.test(key)));
+}

package/dist/index.d.ts

@@ -0,0 +1,191 @@
+export type JsonRecord = Record<string, unknown>;
+export type BayonAiClientConfig = {
+    apiKey?: string;
+    baseUrl: string;
+    fetch?: typeof fetch;
+};
+export type BayonAiRequestOptions = {
+    apiKey?: string;
+    bearerToken?: string;
+    headers?: Record<string, string>;
+};
+export type BayonAiChatMessage = {
+    role: string;
+    content: string;
+    metadata?: JsonRecord;
+};
+export type BayonAiAttachment = {
+    path: string;
+    contentType: string;
+};
+export type BayonAiChatRequest = {
+    attachments?: BayonAiAttachment[];
+    convoId?: string;
+    messages: BayonAiChatMessage[];
+    model?: string;
+    orgId?: string;
+    personaId: string;
+};
+export type BayonAiChatResponse = {
+    convoId?: string;
+    message: BayonAiChatMessage;
+    messages?: BayonAiChatMessage[];
+};
+export type ExternalAuthTokenRequest = {
+    bio?: string;
+    displayName?: string;
+    email?: string;
+    expiresIn?: number;
+    externalUserId: string;
+    metadata?: JsonRecord;
+    photoURL?: string;
+    subscription?: JsonRecord;
+};
+export type ExternalAuthTokenResponse = {
+    accessToken: string;
+    expiresIn: number;
+    tokenType: string;
+    user: JsonRecord;
+};
+export type BayonAiErrorKind = "http" | "network" | "parse" | "config";
+export declare class BayonAiError extends Error {
+    readonly details?: unknown;
+    readonly endpoint: string;
+    readonly kind: BayonAiErrorKind;
+    readonly status?: number;
+    constructor({ details, endpoint, kind, message, status, }: {
+        details?: unknown;
+        endpoint: string;
+        kind: BayonAiErrorKind;
+        message: string;
+        status?: number;
+    });
+}
+export declare function createBayonAiClient(config: BayonAiClientConfig): {
+    a2a: {
+        agentCard: <T = JsonRecord>(personaId: string, options?: BayonAiRequestOptions) => Promise<T>;
+    };
+    admin: {
+        contacts: {
+            send: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        conversations: {
+            all: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        interfaces: {
+            add: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            all: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            delete: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            update: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        organizations: {
+            all: <T = JsonRecord>(body?: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            customMany: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            customSet: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            mine: <T = JsonRecord>(body?: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            role: <T = {
+                role?: string;
+            }>(body?: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        personas: {
+            createOrUpdate: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            get: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            set: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            systemPrompt: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        stats: {
+            events: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            requests: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        tracking: {
+            consumption: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            events: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            requests: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            usage: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        users: {
+            all: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            current: <T = JsonRecord>(body?: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            get: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            stats: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+    };
+    agents: {
+        assigned: <T = JsonRecord>(body?: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        get: <T = JsonRecord>(id: string, options?: BayonAiRequestOptions) => Promise<T>;
+        getPost: <T = JsonRecord>(id: string, options?: BayonAiRequestOptions) => Promise<T>;
+    };
+    conversations: {
+        all: <T = JsonRecord>(body?: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        close: <T = JsonRecord>(convoId: string, options?: BayonAiRequestOptions) => Promise<T>;
+        last: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        own: <T = JsonRecord>(convoId: string, options?: BayonAiRequestOptions) => Promise<T>;
+        send: (body: BayonAiChatRequest, options?: BayonAiRequestOptions) => Promise<BayonAiChatResponse>;
+        star: <T = JsonRecord>(convoId: string, star: boolean, options?: BayonAiRequestOptions) => Promise<T>;
+        summary: <T = {
+            convoId: string;
+            summary: string;
+        }>(convoId: string, options?: BayonAiRequestOptions) => Promise<T>;
+        title: <T = {
+            convoId: string;
+            title: string;
+        }>(convoId: string, options?: BayonAiRequestOptions) => Promise<T>;
+        setTitle: <T = {
+            convoId: string;
+            title: string;
+        }>(convoId: string, title: string, options?: BayonAiRequestOptions) => Promise<T>;
+    };
+    externalAuth: {
+        createToken: (body: ExternalAuthTokenRequest, options?: BayonAiRequestOptions) => Promise<ExternalAuthTokenResponse>;
+    };
+    externalUsers: {
+        me: <T = JsonRecord>(options?: BayonAiRequestOptions) => Promise<T>;
+    };
+    feedback: {
+        submit: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+    };
+    platform: {
+        const: {
+            get: <T = JsonRecord>(name: string, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        data: {
+            reload: <T = JsonRecord>(body?: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        log: {
+            write: <T = JsonRecord>(body?: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        messenger: {
+            receive: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            send: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            webhook: <T = JsonRecord>(query?: Record<string, string | number | boolean | undefined>, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        respondIo: {
+            convoClosed: <T = JsonRecord>(orgId: string, body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            convoOpened: <T = JsonRecord>(orgId: string, body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            log: <T = JsonRecord>(orgId: string, body?: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            messageReceived: <T = JsonRecord>(orgId: string, body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            messageSent: <T = JsonRecord>(orgId: string, body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        twilio: {
+            receive: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            send: <T = JsonRecord>(query?: Record<string, string | number | boolean | undefined>, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+        whatsapp: {
+            send: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+            subscribe: <T = JsonRecord>(query?: Record<string, string | number | boolean | undefined>, options?: BayonAiRequestOptions) => Promise<T>;
+            webhook: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        };
+    };
+    raw: {
+        get: <T = unknown>(path: string, query?: Record<string, string | number | boolean | undefined>, options?: BayonAiRequestOptions) => Promise<T>;
+        post: <T = unknown>(path: string, body?: unknown, options?: BayonAiRequestOptions) => Promise<T>;
+    };
+    stats: {
+        current: <T = JsonRecord>(query?: Record<string, string | number | boolean | undefined>, options?: BayonAiRequestOptions) => Promise<T>;
+        events: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+    };
+    subscriptions: {
+        extend: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+        level: <T = JsonRecord>(body: JsonRecord, options?: BayonAiRequestOptions) => Promise<T>;
+    };
+};

package/dist/index.js

@@ -0,0 +1,263 @@
+export class BayonAiError extends Error {
+    details;
+    endpoint;
+    kind;
+    status;
+    constructor({ details, endpoint, kind, message, status, }) {
+        super(message);
+        this.name = "BayonAiError";
+        this.details = details;
+        this.endpoint = endpoint;
+        this.kind = kind;
+        this.status = status;
+    }
+}
+export function createBayonAiClient(config) {
+    const transport = createTransport(config);
+    return {
+        a2a: {
+            agentCard: (personaId, options) => transport(`/agent/card/${encodePathPart(personaId)}`, {
+                method: "GET",
+                options,
+            }),
+        },
+        admin: {
+            contacts: {
+                send: (body, options) => post(transport, "/admin/contacts", body, options),
+            },
+            conversations: {
+                all: (body, options) => post(transport, "/admin/convo/all", body, options),
+            },
+            interfaces: {
+                add: (body, options) => post(transport, "/admin/interfaces/add", body, options),
+                all: (body, options) => post(transport, "/admin/interfaces/all", body, options),
+                delete: (body, options) => post(transport, "/admin/interfaces/delete", body, options),
+                update: (body, options) => post(transport, "/admin/interfaces/update", body, options),
+            },
+            organizations: {
+                all: (body = {}, options) => post(transport, "/admin/org/all", body, options),
+                customMany: (body, options) => post(transport, "/admin/org/custom/many", body, options),
+                customSet: (body, options) => post(transport, "/admin/org/custom/set", body, options),
+                mine: (body = {}, options) => post(transport, "/admin/org/mine", body, options),
+                role: (body = {}, options) => post(transport, "/admin/org/role", body, options),
+            },
+            personas: {
+                createOrUpdate: (body, options) => post(transport, "/admin/personas", body, options),
+                get: (body, options) => post(transport, "/admin/personas/get", body, options),
+                set: (body, options) => post(transport, "/admin/personas/set", body, options),
+                systemPrompt: (body, options) => post(transport, "/admin/personas/sys_prompt", body, options),
+            },
+            stats: {
+                events: (body, options) => post(transport, "/admin/stats/events", body, options),
+                requests: (body, options) => post(transport, "/admin/stats/requests", body, options),
+            },
+            tracking: {
+                consumption: (body, options) => post(transport, "/admin/tracking/consumption", body, options),
+                events: (body, options) => post(transport, "/admin/tracking/events", body, options),
+                requests: (body, options) => post(transport, "/admin/tracking/requests", body, options),
+                usage: (body, options) => post(transport, "/admin/tracking/usage", body, options),
+            },
+            users: {
+                all: (body, options) => post(transport, "/admin/users/all", body, options),
+                current: (body = {}, options) => post(transport, "/admin/users/current", body, options),
+                get: (body, options) => post(transport, "/admin/users/get", body, options),
+                stats: (body, options) => post(transport, "/admin/users/stats", body, options),
+            },
+        },
+        agents: {
+            assigned: (body = {}, options) => post(transport, "/agents/assigned", body, options),
+            get: (id, options) => transport("/agents/get", {
+                method: "GET",
+                options,
+                query: { id },
+            }),
+            getPost: (id, options) => post(transport, "/agents/get", { id }, options),
+        },
+        conversations: {
+            all: (body = {}, options) => post(transport, "/convo/all", body, options),
+            close: (convoId, options) => post(transport, "/convo/close", { convoId }, options),
+            last: (body, options) => post(transport, "/convo/last", body, options),
+            own: (convoId, options) => post(transport, "/convo/own", { convoId }, options),
+            send: (body, options) => post(transport, "/convo/send", {
+                ...omitUndefined(body),
+                messages: JSON.stringify(body.messages),
+            }, options),
+            star: (convoId, star, options) => post(transport, "/convo/star", { convoId, star }, options),
+            summary: (convoId, options) => post(transport, "/convo/summary", { convoId }, options),
+            title: (convoId, options) => post(transport, "/convo/title", { convoId }, options),
+            setTitle: (convoId, title, options) => post(transport, "/convo/title/set", { convoId, title }, options),
+        },
+        externalAuth: {
+            createToken: (body, options) => post(transport, "/external/auth/token", body, options),
+        },
+        externalUsers: {
+            me: (options) => transport("/external/users/me", { method: "GET", options }),
+        },
+        feedback: {
+            submit: (body, options) => post(transport, "/feedback", body, options),
+        },
+        platform: {
+            const: {
+                get: (name, options) => transport(`/const/${encodePathPart(name)}`, {
+                    method: "GET",
+                    options,
+                }),
+            },
+            data: {
+                reload: (body = {}, options) => post(transport, "/data/reload", body, options),
+            },
+            log: {
+                write: (body = {}, options) => post(transport, "/log", body, options),
+            },
+            messenger: {
+                receive: (body, options) => post(transport, "/messenger/receive", body, options),
+                send: (body, options) => post(transport, "/messenger/send", body, options),
+                webhook: (query = {}, options) => transport("/messenger/webhook", {
+                    method: "GET",
+                    options,
+                    query,
+                }),
+            },
+            respondIo: {
+                convoClosed: (orgId, body, options) => post(transport, `/respondio/${encodePathPart(orgId)}/convo_closed`, body, options),
+                convoOpened: (orgId, body, options) => post(transport, `/respondio/${encodePathPart(orgId)}/convo_opened`, body, options),
+                log: (orgId, body = {}, options) => post(transport, `/respondio/${encodePathPart(orgId)}/log`, body, options),
+                messageReceived: (orgId, body, options) => post(transport, `/respondio/${encodePathPart(orgId)}/message_received`, body, options),
+                messageSent: (orgId, body, options) => post(transport, `/respondio/${encodePathPart(orgId)}/message_sent`, body, options),
+            },
+            twilio: {
+                receive: (body, options) => post(transport, "/twilio/receive", body, options),
+                send: (query = {}, options) => transport("/twilio/send", { method: "GET", options, query }),
+            },
+            whatsapp: {
+                send: (body, options) => post(transport, "/whatsapp/send", body, options),
+                subscribe: (query = {}, options) => transport("/whatsapp/subscribe", {
+                    method: "GET",
+                    options,
+                    query,
+                }),
+                webhook: (body, options) => post(transport, "/whatsapp/webhook", body, options),
+            },
+        },
+        raw: {
+            get: (path, query, options) => transport(path, { method: "GET", options, query }),
+            post: (path, body, options) => transport(path, { body, method: "POST", options }),
+        },
+        stats: {
+            current: (query = {}, options) => transport("/stats", { method: "GET", options, query }),
+            events: (body, options) => post(transport, "/stats/events", body, options),
+        },
+        subscriptions: {
+            extend: (body, options) => post(transport, "/subscriptions/extend", body, options),
+            level: (body, options) => post(transport, "/subscriptions/level", body, options),
+        },
+    };
+}
+function createTransport(config) {
+    return async function request(endpoint, { body, method = "POST", options, query } = {}) {
+        const fetchImpl = config.fetch ?? globalThis.fetch;
+        if (!fetchImpl) {
+            throw new BayonAiError({
+                endpoint,
+                kind: "config",
+                message: "A fetch implementation is required.",
+            });
+        }
+        const url = buildUrl(config.baseUrl, endpoint, query);
+        let response;
+        try {
+            response = await fetchImpl(url, {
+                method,
+                headers: buildHeaders(config, options, body !== undefined),
+                ...(body === undefined ? {} : { body: JSON.stringify(omitUndefined(body)) }),
+            });
+        }
+        catch (error) {
+            throw new BayonAiError({
+                details: sanitizeDetails(error),
+                endpoint,
+                kind: "network",
+                message: `BayonAI request failed for ${endpoint}.`,
+            });
+        }
+        const data = await readResponseJson(response, endpoint);
+        if (!response.ok) {
+            throw new BayonAiError({
+                details: sanitizeDetails(data),
+                endpoint,
+                kind: "http",
+                message: `BayonAI request failed with HTTP ${response.status}.`,
+                status: response.status,
+            });
+        }
+        return data;
+    };
+}
+function post(transport, endpoint, body, options) {
+    return transport(endpoint, { body, method: "POST", options });
+}
+function buildHeaders(config, options, hasBody) {
+    const headers = {
+        ...(hasBody ? { "Content-Type": "application/json" } : {}),
+        ...(options?.headers ?? {}),
+    };
+    if (options?.bearerToken) {
+        headers.Authorization = `Bearer ${options.bearerToken}`;
+        return headers;
+    }
+    const apiKey = options?.apiKey ?? config.apiKey;
+    if (apiKey) {
+        headers["x-api-key"] = apiKey;
+    }
+    return headers;
+}
+function buildUrl(baseUrl, endpoint, query) {
+    const normalizedBase = baseUrl.replace(/\/+$/, "");
+    const normalizedEndpoint = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+    const url = new URL(`${normalizedBase}${normalizedEndpoint}`);
+    Object.entries(query ?? {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            url.searchParams.set(key, String(value));
+        }
+    });
+    return url.toString();
+}
+function encodePathPart(value) {
+    return encodeURIComponent(value);
+}
+async function readResponseJson(response, endpoint) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.includes("application/json")) {
+        if (response.ok) {
+            return response.text();
+        }
+        return null;
+    }
+    try {
+        return await response.json();
+    }
+    catch (error) {
+        throw new BayonAiError({
+            details: sanitizeDetails(error),
+            endpoint,
+            kind: "parse",
+            message: `BayonAI returned invalid JSON for ${endpoint}.`,
+            status: response.status,
+        });
+    }
+}
+function omitUndefined(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== undefined));
+}
+function sanitizeDetails(value) {
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    if (value instanceof Error) {
+        return { message: value.message };
+    }
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !/(key|token|authorization|secret|password)/i.test(key)));
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@bayonai/sdk",
+  "version": "0.1.0",
+  "description": "TypeScript SDK for the BayonAI Firebase API.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BayonAI/bounded.git",
+    "directory": "packages/bayonai-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/BayonAI/bounded/issues"
+  },
+  "homepage": "https://bayonai.com",
+  "keywords": [
+    "bayonai",
+    "gai",
+    "firebase",
+    "ai",
+    "sdk"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node scripts/write-cjs.mjs",
+    "lint": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run",
+    "pack": "pnpm pack"
+  },
+  "devDependencies": {
+    "typescript": "^5",
+    "vitest": "^4.1.6"
+  }
+}