@promptev/client 0.0.2 → 0.1.0

package/dist/esm/index.js

@@ -1,103 +1,283 @@
-import axios from "axios";
+// ── Types ───────────────────────────────────────────────
+// ── Errors ──────────────────────────────────────────────
+export class PromptevError extends Error {
+    constructor(message, statusCode, responseText) {
+        super(message);
+        this.name = "PromptevError";
+        this.statusCode = statusCode;
+        this.responseText = responseText;
+    }
+}
+export class ValidationError extends PromptevError {
+    constructor(message, statusCode, responseText) {
+        super(message, statusCode, responseText);
+        this.name = "ValidationError";
+    }
+}
+export class AuthenticationError extends PromptevError {
+    constructor(message, statusCode, responseText) {
+        super(message, statusCode, responseText);
+        this.name = "AuthenticationError";
+    }
+}
+export class NotFoundError extends PromptevError {
+    constructor(message, statusCode, responseText) {
+        super(message, statusCode, responseText);
+        this.name = "NotFoundError";
+    }
+}
+export class RateLimitError extends PromptevError {
+    constructor(message, statusCode, responseText) {
+        super(message, statusCode, responseText);
+        this.name = "RateLimitError";
+    }
+}
+export class ServerError extends PromptevError {
+    constructor(message, statusCode, responseText) {
+        super(message, statusCode, responseText);
+        this.name = "ServerError";
+    }
+}
+export class NetworkError extends PromptevError {
+    constructor(message, statusCode, responseText) {
+        super(message, statusCode, responseText);
+        this.name = "NetworkError";
+    }
+}
+// ── Client ──────────────────────────────────────────────
+const RETRYABLE_STATUS = new Set([502, 503, 504]);
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_BACKOFF = 500; // ms
 export 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.create({ baseURL: this.baseUrl });
-        const isNode = typeof window === "undefined";
-        this.isReady = (async () => {
-            if (isNode) {
-                const { default: NodeCache } = await import("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();
+        }
+    }
+    // ── 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 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;
+    /**
+     * 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);
     }
-    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);
+    // ── 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);
     }
 }
 export default PromptevClient;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@promptev/client",
-  "version": "0.0.2",
-  "description": "Client library for accessing Promptev API",
+  "version": "0.1.0",
+  "description": "JavaScript/TypeScript SDK for Promptev — run AI prompts and agents programmatically",
   "type": "module",
   "main": "./dist/cjs/index.cjs",
   "module": "./dist/esm/index.js",
@@ -32,9 +32,9 @@
     "client",
     "sdk",
     "ai",
-    "promptDev",
-    "promptdev",
-    "promptops",
+    "agents",
+    "agent-sdk",
+    "context-engineering",
     "typescript",
     "javascript"
   ],
@@ -44,10 +44,7 @@
     "build:cjs": "tsc -p tsconfig.cjs.json && node scripts/rename-cjs.cjs",
     "build": "npm run build:esm && npm run build:cjs"
   },
-  "dependencies": {
-    "axios": "^1.10.0",
-    "node-cache": "^5.1.2"
-  },
+  "dependencies": {},
   "devDependencies": {
     "@types/node": "^20.10.0",
     "ts-node": "^10.9.2",