smoothagent 0.1.0

package/index.d.ts

@@ -0,0 +1,112 @@
+export interface SmoothAgentOptions {
+  /** User JWT token (for chat operations) */
+  token?: string;
+  /** Admin JWT token (for project/user management) */
+  adminToken?: string;
+  /** Worker URL. Defaults to window.location.origin or https://agent.smoothcodes.com */
+  workerUrl?: string;
+}
+
+export interface PromptOptions {
+  /** Called for each text delta */
+  onDelta?: (delta: string, fullText: string) => void;
+  /** Called when a tool is invoked */
+  onToolCall?: (info: { toolCallId: string; toolName: string }) => void;
+  /** Called when a tool returns a result */
+  onToolResult?: (info: { toolCallId: string; result: unknown }) => void;
+  /** Called when streaming finishes */
+  onFinish?: (info: { text: string; reason?: string }) => void;
+  /** Called on error */
+  onError?: (error: string) => void;
+  /** Override config for this prompt */
+  config?: Record<string, unknown>;
+}
+
+export interface ChatOptions {
+  /** Override config */
+  config?: Record<string, unknown>;
+  onDelta?: (delta: string, fullText: string) => void;
+  onFinish?: (info: { text: string }) => void;
+}
+
+export interface Chat {
+  id: string;
+  configId?: string;
+  userId?: string;
+  title?: string;
+  messages?: Array<{ role: string; content: string }>;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface Project {
+  id: string;
+  mcpUrl?: string;
+  llmProvider?: string;
+  llmModel?: string;
+  themeName?: string;
+  themeColor?: string;
+  plan?: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface PromptResult {
+  text: string;
+  promptId?: string | null;
+}
+
+export interface AuthResult {
+  token: string;
+  devId: string;
+  email: string;
+  plan?: string;
+  chatToken?: string;
+  verified?: boolean;
+}
+
+export interface UserTokenResult {
+  token: string;
+  configId: string;
+  userId: string;
+  expiresIn: string;
+}
+
+export declare class SmoothAgent {
+  token: string | null;
+  adminToken: string | null;
+  workerUrl: string;
+
+  constructor(options?: SmoothAgentOptions);
+
+  // Auth
+  signup(email: string, password: string): Promise<AuthResult>;
+  login(email: string, password: string): Promise<AuthResult>;
+  me(): Promise<{ id: string; email: string; plan: string; createdAt: string; configsCount: number }>;
+
+  // Users
+  createUser(userId: string, options?: { configId?: string; plan?: string }): Promise<UserTokenResult>;
+
+  // Chats
+  createChat(title?: string): Promise<Chat>;
+  listChats(): Promise<Chat[]>;
+  getChat(chatId: string): Promise<Chat>;
+  deleteChat(chatId: string): Promise<{ cancelled: number }>;
+
+  // Prompts (streaming)
+  prompt(chatId: string, content: string, options?: PromptOptions): Promise<PromptResult>;
+
+  // Stateless chat (no history)
+  chat(messages: Array<{ role: string; content: string }>, options?: ChatOptions): Promise<PromptResult>;
+
+  // Projects (admin/dev)
+  createProject(data: { mcpUrl: string; llmProvider: string; llmApiKey: string; [key: string]: unknown }): Promise<{ id: string }>;
+  listProjects(): Promise<Project[]>;
+  updateProject(id: string, data: Partial<Project>): Promise<{ ok: boolean }>;
+  deleteProject(id: string): Promise<{ ok: boolean }>;
+
+  // Usage
+  getUsage(configId: string, days?: number): Promise<{ days: unknown[]; totals: Record<string, number>; period: string }>;
+}
+
+export default SmoothAgent;

package/index.js

@@ -0,0 +1,118 @@
+"use strict";
+
+class SmoothAgent {
+  constructor({ token, adminToken, workerUrl } = {}) {
+    this.token = token || null;
+    this.adminToken = adminToken || null;
+    this.workerUrl = workerUrl || (typeof window !== 'undefined' ? window.location?.origin : null) || 'https://agent.smoothcodes.com';
+  }
+
+  async signup(email, password) { return this._post('/auth/signup', { email, password }); }
+  async login(email, password) { return this._post('/auth/login', { email, password }); }
+  async me() { return this._get('/auth/me'); }
+
+  async createUser(userId, { configId, plan } = {}) {
+    const cfgId = configId || this._configIdFromToken();
+    if (!cfgId) throw new Error('configId required');
+    return this._post(`/dashboard/configs/${cfgId}/token`, { userId, plan });
+  }
+
+  async createChat(title) { return this._post('/chats', title ? { title } : {}); }
+  async listChats() { const d = await this._get('/chats'); return d.chats || []; }
+  async getChat(chatId) { return this._get(`/chats/${chatId}`); }
+  async deleteChat(chatId) { return this._fetch('DELETE', `/chats/${chatId}/prompt`); }
+
+  async prompt(chatId, content, opts = {}) {
+    const body = { content };
+    if (opts.config) body.config = opts.config;
+    const res = await fetch(`${this.workerUrl}/chats/${chatId}/prompt`, {
+      method: 'POST', headers: this._headers(), body: JSON.stringify(body),
+    });
+    if (!res.ok) { const e = await res.json().catch(() => ({})); throw new Error(e.error || `HTTP ${res.status}`); }
+    return this._consumeStream(res, opts);
+  }
+
+  async chat(messages, opts = {}) {
+    const body = { messages };
+    if (opts.config) body.config = opts.config;
+    const res = await fetch(`${this.workerUrl}/chat`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return this._consumeStream(res, opts);
+  }
+
+  async createProject(data) { return this._post('/dashboard/configs', data); }
+  async listProjects() { const d = await this._get('/dashboard/configs'); return d.configs || []; }
+  async updateProject(id, data) { return this._fetch('PUT', `/dashboard/configs/${id}`, data); }
+  async deleteProject(id) { return this._fetch('DELETE', `/dashboard/configs/${id}`); }
+  async getUsage(configId, days = 7) { return this._get(`/dashboard/usage?configId=${configId}&days=${days}`); }
+
+  _headers() {
+    const h = { 'Content-Type': 'application/json' };
+    const t = this.token || this.adminToken;
+    if (t) h['Authorization'] = `Bearer ${t}`;
+    return h;
+  }
+
+  async _get(path) {
+    const res = await fetch(`${this.workerUrl}${path}`, { headers: this._headers() });
+    if (!res.ok) { const e = await res.json().catch(() => ({})); throw new Error(e.error || `HTTP ${res.status}`); }
+    return res.json();
+  }
+
+  async _post(path, body) {
+    const res = await fetch(`${this.workerUrl}${path}`, {
+      method: 'POST', headers: this._headers(), body: JSON.stringify(body || {}),
+    });
+    if (!res.ok) { const e = await res.json().catch(() => ({})); throw new Error(e.error || `HTTP ${res.status}`); }
+    return res.json();
+  }
+
+  async _fetch(method, path, body) {
+    const opts = { method, headers: this._headers() };
+    if (body) opts.body = JSON.stringify(body);
+    const res = await fetch(`${this.workerUrl}${path}`, opts);
+    if (!res.ok) { const e = await res.json().catch(() => ({})); throw new Error(e.error || `HTTP ${res.status}`); }
+    return res.json();
+  }
+
+  async _consumeStream(res, { onDelta, onToolCall, onToolResult, onFinish, onError } = {}) {
+    let fullText = '';
+    const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
+    let buffer = '';
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += value;
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('data: ')) continue;
+        const payload = trimmed.slice(6);
+        if (payload === '[DONE]') continue;
+        try {
+          const data = JSON.parse(payload);
+          switch (data.type) {
+            case 'text-delta': fullText += data.delta; if (onDelta) onDelta(data.delta, fullText); break;
+            case 'tool-input-start': case 'tool-call': if (onToolCall) onToolCall({ toolCallId: data.toolCallId, toolName: data.toolName }); break;
+            case 'tool-output-available': case 'tool-result': if (onToolResult) onToolResult({ toolCallId: data.toolCallId, result: data.result || data.output }); break;
+            case 'error': if (onError) onError(data.errorText || data.message); break;
+            case 'finish': if (onFinish) onFinish({ text: fullText, reason: data.finishReason }); break;
+          }
+        } catch {}
+      }
+    }
+    return { text: fullText, promptId: res.headers.get('X-Prompt-Id') };
+  }
+
+  _configIdFromToken() {
+    if (!this.adminToken) return null;
+    try { return JSON.parse(atob(this.adminToken.split('.')[1])).configId || null; } catch { return null; }
+  }
+}
+
+module.exports = { SmoothAgent };
+module.exports.SmoothAgent = SmoothAgent;
+module.exports.default = SmoothAgent;

package/index.mjs

@@ -0,0 +1,209 @@
+/**
+ * SmoothAgent SDK
+ * Zero deps. Works in browser and Node.js.
+ *
+ * @example
+ * import { SmoothAgent } from 'smoothagent';
+ *
+ * const agent = new SmoothAgent({ token: 'your_jwt_token' });
+ * const chat = await agent.createChat();
+ * const { text } = await agent.prompt(chat.id, 'Hello!', {
+ *   onDelta: (delta) => process.stdout.write(delta),
+ * });
+ */
+
+export class SmoothAgent {
+  constructor({ token, adminToken, workerUrl } = {}) {
+    this.token = token || null;
+    this.adminToken = adminToken || null;
+    this.workerUrl = workerUrl || (typeof window !== 'undefined' ? window.location?.origin : null) || 'https://agent.smoothcodes.com';
+  }
+
+  // === Auth ===
+
+  async signup(email, password) {
+    return this._post('/auth/signup', { email, password });
+  }
+
+  async login(email, password) {
+    return this._post('/auth/login', { email, password });
+  }
+
+  async me() {
+    return this._get('/auth/me');
+  }
+
+  // === Users (admin) ===
+
+  async createUser(userId, { configId, plan } = {}) {
+    const cfgId = configId || this._configIdFromToken();
+    if (!cfgId) throw new Error('configId required — pass configId or use a token with configId');
+    return this._post(`/dashboard/configs/${cfgId}/token`, { userId, plan });
+  }
+
+  // === Chats ===
+
+  async createChat(title) {
+    return this._post('/chats', title ? { title } : {});
+  }
+
+  async listChats() {
+    const data = await this._get('/chats');
+    return data.chats || [];
+  }
+
+  async getChat(chatId) {
+    return this._get(`/chats/${chatId}`);
+  }
+
+  async deleteChat(chatId) {
+    return this._fetch('DELETE', `/chats/${chatId}/prompt`);
+  }
+
+  // === Prompts ===
+
+  async prompt(chatId, content, { onDelta, onToolCall, onToolResult, onFinish, onError, config } = {}) {
+    const body = { content };
+    if (config) body.config = config;
+
+    const res = await fetch(`${this.workerUrl}/chats/${chatId}/prompt`, {
+      method: 'POST',
+      headers: this._headers(),
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+      throw new Error(err.error || `HTTP ${res.status}`);
+    }
+
+    return this._consumeStream(res, { onDelta, onToolCall, onToolResult, onFinish, onError });
+  }
+
+  // === Stateless chat (no history) ===
+
+  async chat(messages, { config, onDelta, onFinish } = {}) {
+    const body = { messages };
+    if (config) body.config = config;
+
+    const res = await fetch(`${this.workerUrl}/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return this._consumeStream(res, { onDelta, onFinish });
+  }
+
+  // === Projects (admin/dev) ===
+
+  async createProject(data) {
+    return this._post('/dashboard/configs', data);
+  }
+
+  async listProjects() {
+    const data = await this._get('/dashboard/configs');
+    return data.configs || [];
+  }
+
+  async updateProject(id, data) {
+    return this._fetch('PUT', `/dashboard/configs/${id}`, data);
+  }
+
+  async deleteProject(id) {
+    return this._fetch('DELETE', `/dashboard/configs/${id}`);
+  }
+
+  // === Usage ===
+
+  async getUsage(configId, days = 7) {
+    return this._get(`/dashboard/usage?configId=${configId}&days=${days}`);
+  }
+
+  // === Internal ===
+
+  _headers() {
+    const h = { 'Content-Type': 'application/json' };
+    const t = this.token || this.adminToken;
+    if (t) h['Authorization'] = `Bearer ${t}`;
+    return h;
+  }
+
+  async _get(path) {
+    const res = await fetch(`${this.workerUrl}${path}`, { headers: this._headers() });
+    if (!res.ok) { const e = await res.json().catch(() => ({})); throw new Error(e.error || `HTTP ${res.status}`); }
+    return res.json();
+  }
+
+  async _post(path, body) {
+    const res = await fetch(`${this.workerUrl}${path}`, {
+      method: 'POST', headers: this._headers(), body: JSON.stringify(body || {}),
+    });
+    if (!res.ok) { const e = await res.json().catch(() => ({})); throw new Error(e.error || `HTTP ${res.status}`); }
+    return res.json();
+  }
+
+  async _fetch(method, path, body) {
+    const opts = { method, headers: this._headers() };
+    if (body) opts.body = JSON.stringify(body);
+    const res = await fetch(`${this.workerUrl}${path}`, opts);
+    if (!res.ok) { const e = await res.json().catch(() => ({})); throw new Error(e.error || `HTTP ${res.status}`); }
+    return res.json();
+  }
+
+  async _consumeStream(res, { onDelta, onToolCall, onToolResult, onFinish, onError } = {}) {
+    let fullText = '';
+    const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += value;
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('data: ')) continue;
+        const payload = trimmed.slice(6);
+        if (payload === '[DONE]') continue;
+
+        try {
+          const data = JSON.parse(payload);
+          switch (data.type) {
+            case 'text-delta':
+              fullText += data.delta;
+              if (onDelta) onDelta(data.delta, fullText);
+              break;
+            case 'tool-input-start':
+            case 'tool-call':
+              if (onToolCall) onToolCall({ toolCallId: data.toolCallId, toolName: data.toolName });
+              break;
+            case 'tool-output-available':
+            case 'tool-result':
+              if (onToolResult) onToolResult({ toolCallId: data.toolCallId, result: data.result || data.output });
+              break;
+            case 'error':
+              if (onError) onError(data.errorText || data.message);
+              break;
+            case 'finish':
+              if (onFinish) onFinish({ text: fullText, reason: data.finishReason });
+              break;
+          }
+        } catch {}
+      }
+    }
+
+    return { text: fullText, promptId: res.headers.get('X-Prompt-Id') };
+  }
+
+  _configIdFromToken() {
+    if (!this.adminToken) return null;
+    try {
+      const payload = JSON.parse(atob(this.adminToken.split('.')[1]));
+      return payload.configId || null;
+    } catch { return null; }
+  }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "smoothagent",
+  "version": "0.1.0",
+  "description": "SmoothAgent SDK — white-label agentic chat with MCP tools. Browser + Node.js.",
+  "main": "index.js",
+  "module": "index.mjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "types": "./index.d.ts"
+    }
+  },
+  "files": [
+    "index.js",
+    "index.mjs",
+    "index.d.ts"
+  ],
+  "keywords": [
+    "smooth",
+    "agent",
+    "chat",
+    "agentic",
+    "mcp",
+    "llm",
+    "ai",
+    "anthropic",
+    "openai",
+    "google",
+    "white-label",
+    "sdk"
+  ],
+  "author": "SmoothAgent",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/joaoquirino/smoothagent"
+  },
+  "homepage": "https://agent.smoothcodes.com"
+}