@promptev/client 0.0.2 → 0.1.0

package/dist/cjs/index.cjs

@@ -1,142 +1,293 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+// ── Types ───────────────────────────────────────────────
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromptevClient = void 0;
-const axios_1 = __importDefault(require("axios"));
+exports.PromptevClient = exports.NetworkError = exports.ServerError = exports.RateLimitError = exports.NotFoundError = exports.AuthenticationError = exports.ValidationError = exports.PromptevError = void 0;
+// ── Errors ──────────────────────────────────────────────
+class PromptevError extends Error {
+    constructor(message, statusCode, responseText) {
+        super(message);
+        this.name = "PromptevError";
+        this.statusCode = statusCode;
+        this.responseText = responseText;
+    }
+}
+exports.PromptevError = PromptevError;
+class ValidationError extends PromptevError {
+    constructor(message, statusCode, responseText) {
+        super(message, statusCode, responseText);
+        this.name = "ValidationError";
+    }
+}
+exports.ValidationError = ValidationError;
+class AuthenticationError extends PromptevError {
+    constructor(message, statusCode, responseText) {
+        super(message, statusCode, responseText);
+        this.name = "AuthenticationError";
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class NotFoundError extends PromptevError {
+    constructor(message, statusCode, responseText) {
+        super(message, statusCode, responseText);
+        this.name = "NotFoundError";
+    }
+}
+exports.NotFoundError = NotFoundError;
+class RateLimitError extends PromptevError {
+    constructor(message, statusCode, responseText) {
+        super(message, statusCode, responseText);
+        this.name = "RateLimitError";
+    }
+}
+exports.RateLimitError = RateLimitError;
+class ServerError extends PromptevError {
+    constructor(message, statusCode, responseText) {
+        super(message, statusCode, responseText);
+        this.name = "ServerError";
+    }
+}
+exports.ServerError = ServerError;
+class NetworkError extends PromptevError {
+    constructor(message, statusCode, responseText) {
+        super(message, statusCode, responseText);
+        this.name = "NetworkError";
+    }
+}
+exports.NetworkError = NetworkError;
+// ── Client ──────────────────────────────────────────────
+const RETRYABLE_STATUS = new Set([502, 503, 504]);
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_BACKOFF = 500; // ms
 class PromptevClient {
     constructor(config) {
-        this.refreshInterval = null;
-        this.baseUrl = config.baseUrl || "https://api.promptev.ai";
         this.projectKey = config.projectKey;
-        this.cacheRefreshIntervalMs = config.cacheRefreshIntervalMs || 30000;
-        this.client = axios_1.default.create({ baseURL: this.baseUrl });
-        const isNode = typeof window === "undefined";
-        this.isReady = (async () => {
-            if (isNode) {
-                const { default: NodeCache } = await Promise.resolve().then(() => __importStar(require("node-cache")));
-                this.promptCache = new NodeCache({
-                    stdTTL: 3600,
-                    checkperiod: 120,
-                    useClones: false,
+        this.baseUrl = (config.baseUrl ?? "https://api.promptev.ai").replace(/\/+$/, "");
+        this.headers = {
+            "Content-Type": "application/json",
+            ...(config.headers ?? {}),
+        };
+        this.timeout = config.timeout ?? 30000;
+        this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    }
+    // ── Error handling ──────────────────────────────────
+    static raiseForStatus(status, text) {
+        if (status < 400)
+            return;
+        let detail;
+        try {
+            const body = JSON.parse(text);
+            detail =
+                typeof body.detail === "string" ? body.detail : text || "Unknown error";
+        }
+        catch {
+            detail = text || "Unknown error";
+        }
+        if (status === 400)
+            throw new ValidationError(detail, status, text);
+        if (status === 401)
+            throw new AuthenticationError(detail, status, text);
+        if (status === 403)
+            throw new AuthenticationError(detail, status, text);
+        if (status === 404)
+            throw new NotFoundError(detail, status, text);
+        if (status === 429)
+            throw new RateLimitError(detail, status, text);
+        if (status >= 500)
+            throw new ServerError(detail, status, text);
+        throw new PromptevError(detail, status, text);
+    }
+    // ── Retry helper ────────────────────────────────────
+    async fetchWithRetry(url, init) {
+        let lastError = null;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+                const resp = await fetch(url, {
+                    ...init,
+                    signal: controller.signal,
                 });
+                clearTimeout(timeoutId);
+                if (!RETRYABLE_STATUS.has(resp.status) || attempt === this.maxRetries) {
+                    return resp;
+                }
+                lastError = new ServerError(`Server error (${resp.status})`, resp.status);
             }
-            else {
-                this.promptCache = new Map();
+            catch (err) {
+                if (err.name === "AbortError") {
+                    lastError = new NetworkError("Request timed out");
+                }
+                else {
+                    lastError = new NetworkError(`Network error: ${err.message}`);
+                }
+                if (attempt === this.maxRetries)
+                    throw lastError;
             }
-            this.startCacheRefresh();
-        })();
-    }
-    async ensureReady() {
-        await this.isReady;
-    }
-    makeCacheKey(promptKey, variables) {
-        const sorted = Object.keys(variables)
-            .sort()
-            .map(k => `${k}=${variables[k]}`)
-            .join("&");
-        return `${promptKey}:${btoa(sorted)}`;
-    }
-    async fetchPromptFromServer(promptKey) {
-        const url = `/api/sdk/v1/prompt/client/${this.projectKey}/${promptKey}`;
-        const response = await this.client.get(url);
-        const rawPrompt = response.data.prompt;
-        const rawVars = Array.isArray(response.data.variables)
-            ? response.data.variables
-            : typeof response.data.variables === "string"
-                ? response.data.variables.split(",").map(v => v.trim())
-                : [];
-        return { prompt: rawPrompt, variables: rawVars };
-    }
-    async formatPrompt(template, requiredVars, values) {
-        if (!requiredVars.length)
-            return template;
-        const missing = requiredVars.filter(v => !(v in values));
-        if (missing.length)
-            throw new Error(`Missing variables: ${missing.join(", ")}`);
-        let formatted = template;
-        for (const [key, val] of Object.entries(values)) {
-            const pattern = new RegExp(`{{\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*}}`, "g");
-            formatted = formatted.replace(pattern, val);
+            const delay = DEFAULT_BACKOFF * Math.pow(2, attempt);
+            await new Promise((resolve) => setTimeout(resolve, delay));
         }
-        return formatted;
+        throw lastError;
     }
-    startCacheRefresh() {
-        if (this.refreshInterval)
-            clearInterval(this.refreshInterval);
-        this.refreshInterval = setInterval(async () => {
-            await this.ensureReady();
-            const keys = Array.from(this.promptCache instanceof Map ? this.promptCache.keys() : this.promptCache.keys());
-            for (const cacheKey of keys) {
-                const [promptKey, encoded] = cacheKey.split(":");
-                const vars = JSON.parse(atob(encoded));
-                try {
-                    await this.fetchAndCache(promptKey, vars);
+    // ── SSE parser ──────────────────────────────────────
+    async *parseSSE(response) {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (!line.startsWith("data: "))
+                        continue;
+                    try {
+                        const data = JSON.parse(line.slice(6));
+                        const event = {
+                            type: data.type || "unknown",
+                            output: data.output || "",
+                            raw: data,
+                        };
+                        yield event;
+                        if (event.type === "done" || event.type === "error")
+                            return;
+                    }
+                    catch {
+                        continue;
+                    }
                 }
-                catch { }
             }
-        }, this.cacheRefreshIntervalMs);
+        }
+        finally {
+            reader.releaseLock();
+        }
     }
-    async fetchAndCache(promptKey, variables) {
-        const data = await this.fetchPromptFromServer(promptKey);
-        const compiled = await this.formatPrompt(data.prompt, data.variables, variables);
-        const cacheKey = this.makeCacheKey(promptKey, variables);
-        this.promptCache.set(cacheKey, compiled);
-        return compiled;
+    // ── Prompt API ──────────────────────────────────────
+    /**
+     * Compile and execute a prompt.
+     *
+     * If the prompt has a model configured, it compiles the template,
+     * sends it to the LLM, and returns the AI response. If no model
+     * is configured, it returns the compiled template string.
+     */
+    async runPrompt(promptKey, query, variables) {
+        const url = `${this.baseUrl}/api/sdk/v1/prompt/client/${this.projectKey}/${promptKey}`;
+        const merged = { query, ...(variables ?? {}) };
+        const resp = await this.fetchWithRetry(url, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify({ variables: merged }),
+        });
+        const text = await resp.text();
+        PromptevClient.raiseForStatus(resp.status, text);
+        const data = JSON.parse(text);
+        if (typeof data.prompt !== "string") {
+            throw new PromptevError("Unexpected response: missing 'prompt' field");
+        }
+        return data.prompt;
     }
-    async getPrompt(promptKey, variables = {}) {
-        await this.ensureReady();
-        const cacheKey = this.makeCacheKey(promptKey, variables);
-        const cached = this.promptCache.get(cacheKey);
-        if (cached)
-            return cached;
-        return await this.fetchAndCache(promptKey, variables);
+    /**
+     * Compile and execute a prompt with streaming.
+     *
+     * Use this when the prompt has tools attached or you want real-time
+     * output. Returns the same event types as agent streaming.
+     */
+    async *streamPrompt(promptKey, query, variables) {
+        const url = `${this.baseUrl}/api/sdk/v1/prompt/client/${this.projectKey}/${promptKey}?stream=true`;
+        const merged = { query, ...(variables ?? {}) };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        let resp;
+        try {
+            resp = await fetch(url, {
+                method: "POST",
+                headers: this.headers,
+                body: JSON.stringify({ variables: merged }),
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            clearTimeout(timeoutId);
+            if (err.name === "AbortError")
+                throw new NetworkError("Request timed out");
+            throw new NetworkError(`Network error: ${err.message}`);
+        }
+        clearTimeout(timeoutId);
+        if (resp.status >= 400) {
+            const text = await resp.text();
+            PromptevClient.raiseForStatus(resp.status, text);
+        }
+        const contentType = resp.headers.get("content-type") || "";
+        // Non-streaming fallback: prompt has no model, backend returns JSON
+        if (!contentType.includes("text/event-stream")) {
+            const data = await resp.json();
+            yield {
+                type: "done",
+                output: data.prompt || "",
+                raw: data,
+            };
+            return;
+        }
+        yield* this.parseSSE(resp);
+    }
+    // ── Agent API ───────────────────────────────────────
+    /**
+     * Start a new agent chat session.
+     */
+    async startAgent(chatbotId, options) {
+        const url = `${this.baseUrl}/api/sdk/v1/agent/${this.projectKey}/${chatbotId}/start`;
+        const payload = {};
+        if (options?.visitor != null)
+            payload.visitor = options.visitor;
+        if (options?.platform && options.platform !== "sdk")
+            payload.platform = options.platform;
+        const resp = await this.fetchWithRetry(url, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(payload),
+        });
+        const text = await resp.text();
+        PromptevClient.raiseForStatus(resp.status, text);
+        const data = JSON.parse(text);
+        return {
+            sessionToken: data.session_token,
+            chatbotId: data.chatbot_id,
+            name: data.name,
+            memoryEnabled: data.memory_enabled ?? false,
+            messages: data.messages ?? [],
+        };
     }
-    async dispose() {
-        await this.ensureReady();
-        if (this.refreshInterval)
-            clearInterval(this.refreshInterval);
-        if (this.promptCache instanceof Map) {
-            this.promptCache.clear();
+    /**
+     * Stream an agent response as SSE events.
+     */
+    async *streamAgent(chatbotId, options) {
+        const url = `${this.baseUrl}/api/sdk/v1/agent/${this.projectKey}/${chatbotId}/stream?session_token=${encodeURIComponent(options.sessionToken)}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        let resp;
+        try {
+            resp = await fetch(url, {
+                method: "POST",
+                headers: this.headers,
+                body: JSON.stringify({ query: options.query }),
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            clearTimeout(timeoutId);
+            if (err.name === "AbortError")
+                throw new NetworkError("Request timed out");
+            throw new NetworkError(`Network error: ${err.message}`);
         }
-        else {
-            this.promptCache.flushAll();
-            this.promptCache.close();
+        clearTimeout(timeoutId);
+        if (resp.status >= 400) {
+            const text = await resp.text();
+            PromptevClient.raiseForStatus(resp.status, text);
         }
+        yield* this.parseSSE(resp);
     }
 }
 exports.PromptevClient = PromptevClient;

package/dist/esm/index.d.ts

@@ -1,24 +1,83 @@
 export interface PromptevClientConfig {
-    baseUrl?: string;
     projectKey: string;
-    cacheRefreshIntervalMs?: number;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    maxRetries?: number;
+}
+export interface AgentSession {
+    sessionToken: string;
+    chatbotId: string;
+    name: string;
+    memoryEnabled: boolean;
+    messages: Record<string, any>[];
+}
+export interface AgentEvent {
+    type: string;
+    output: string;
+    raw: Record<string, any>;
+}
+export declare class PromptevError extends Error {
+    statusCode?: number;
+    responseText?: string;
+    constructor(message: string, statusCode?: number, responseText?: string);
+}
+export declare class ValidationError extends PromptevError {
+    constructor(message: string, statusCode?: number, responseText?: string);
+}
+export declare class AuthenticationError extends PromptevError {
+    constructor(message: string, statusCode?: number, responseText?: string);
+}
+export declare class NotFoundError extends PromptevError {
+    constructor(message: string, statusCode?: number, responseText?: string);
+}
+export declare class RateLimitError extends PromptevError {
+    constructor(message: string, statusCode?: number, responseText?: string);
+}
+export declare class ServerError extends PromptevError {
+    constructor(message: string, statusCode?: number, responseText?: string);
+}
+export declare class NetworkError extends PromptevError {
+    constructor(message: string, statusCode?: number, responseText?: string);
 }
 export declare class PromptevClient {
-    private client;
-    private baseUrl;
     private projectKey;
-    private promptCache;
-    private refreshInterval;
-    private cacheRefreshIntervalMs;
-    private isReady;
+    private baseUrl;
+    private headers;
+    private timeout;
+    private maxRetries;
     constructor(config: PromptevClientConfig);
-    private ensureReady;
-    private makeCacheKey;
-    private fetchPromptFromServer;
-    private formatPrompt;
-    private startCacheRefresh;
-    private fetchAndCache;
-    getPrompt(promptKey: string, variables?: Record<string, string>): Promise<string>;
-    dispose(): Promise<void>;
+    private static raiseForStatus;
+    private fetchWithRetry;
+    private parseSSE;
+    /**
+     * Compile and execute a prompt.
+     *
+     * If the prompt has a model configured, it compiles the template,
+     * sends it to the LLM, and returns the AI response. If no model
+     * is configured, it returns the compiled template string.
+     */
+    runPrompt(promptKey: string, query: string, variables?: Record<string, string>): Promise<string>;
+    /**
+     * Compile and execute a prompt with streaming.
+     *
+     * Use this when the prompt has tools attached or you want real-time
+     * output. Returns the same event types as agent streaming.
+     */
+    streamPrompt(promptKey: string, query: string, variables?: Record<string, string>): AsyncGenerator<AgentEvent>;
+    /**
+     * Start a new agent chat session.
+     */
+    startAgent(chatbotId: string, options?: {
+        visitor?: string;
+        platform?: string;
+    }): Promise<AgentSession>;
+    /**
+     * Stream an agent response as SSE events.
+     */
+    streamAgent(chatbotId: string, options: {
+        sessionToken: string;
+        query: string;
+    }): AsyncGenerator<AgentEvent>;
 }
 export default PromptevClient;