@tchavi/sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,599 @@
+// src/core/auth.ts
+var AuthStrategy = class {
+  mode;
+  apiKey;
+  accessToken;
+  tokenExpiresAt;
+  baseURL;
+  email;
+  password;
+  constructor(options) {
+    this.baseURL = options.baseURL ?? "http://localhost:3001";
+    if (options.apiKey) {
+      this.mode = "api-key";
+      this.apiKey = options.apiKey;
+    } else if (options.email && options.password) {
+      this.mode = "jwt";
+      this.email = options.email;
+      this.password = options.password;
+    } else {
+      throw new Error(
+        "TchaviClientOptions must provide either `apiKey` or both `email` and `password`."
+      );
+    }
+  }
+  /**
+   * Returns the Authorization header value for the current request.
+   * For JWT mode, lazily logs in and refreshes the token as needed.
+   */
+  async getAuthHeader() {
+    if (this.mode === "api-key") {
+      return `Bearer ${this.apiKey}`;
+    }
+    if (!this.accessToken || this.isTokenExpired()) {
+      await this.loginOrRefresh();
+    }
+    return `Bearer ${this.accessToken}`;
+  }
+  /** Store a token (e.g. after explicit login() call from AuthResource) */
+  setAccessToken(token, expiresInSeconds = 900) {
+    this.accessToken = token;
+    this.tokenExpiresAt = Date.now() + (expiresInSeconds - 30) * 1e3;
+  }
+  getMode() {
+    return this.mode;
+  }
+  isTokenExpired() {
+    if (!this.tokenExpiresAt) return true;
+    return Date.now() >= this.tokenExpiresAt;
+  }
+  async loginOrRefresh() {
+    const refreshed = await this.tryRefresh();
+    if (!refreshed) {
+      await this.loginWithPassword();
+    }
+  }
+  async tryRefresh() {
+    try {
+      const resp = await fetch(`${this.baseURL}/auth/refresh`, {
+        method: "POST",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" }
+      });
+      if (!resp.ok) return false;
+      const body = await resp.json();
+      this.setAccessToken(body.accessToken);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async loginWithPassword() {
+    const resp = await fetch(`${this.baseURL}/auth/login`, {
+      method: "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email: this.email, password: this.password })
+    });
+    if (!resp.ok) {
+      const body2 = await resp.json().catch(() => ({}));
+      throw new Error(
+        `Tchavi auth failed: ${body2["message"] ?? resp.statusText}`
+      );
+    }
+    const body = await resp.json();
+    this.setAccessToken(body.accessToken);
+  }
+};
+
+// src/errors/TchaviError.ts
+var TchaviError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TchaviError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/errors/TchaviAuthenticationError.ts
+var TchaviAuthenticationError = class extends TchaviAPIError {
+  constructor(response, headers = {}) {
+    super(response, headers);
+    this.name = "TchaviAuthenticationError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/errors/TchaviRateLimitError.ts
+var TchaviRateLimitError = class extends TchaviAPIError {
+  retryAfter;
+  constructor(response, headers = {}) {
+    super(response, headers);
+    this.name = "TchaviRateLimitError";
+    const details = response.details;
+    this.retryAfter = details?.retry_after ?? (headers["retry-after"] ? parseInt(headers["retry-after"], 10) : null);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/errors/TchaviInsufficientCreditsError.ts
+var TchaviInsufficientCreditsError = class extends TchaviAPIError {
+  creditsRemaining;
+  constructor(response, headers = {}) {
+    super(response, headers);
+    this.name = "TchaviInsufficientCreditsError";
+    const details = response.details;
+    this.creditsRemaining = details?.credits_remaining ?? 0;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/errors/TchaviAPIError.ts
+var TchaviAPIError = class _TchaviAPIError extends TchaviError {
+  statusCode;
+  errorCode;
+  details;
+  headers;
+  constructor(response, headers = {}) {
+    super(response.message);
+    this.name = "TchaviAPIError";
+    this.statusCode = response.statusCode;
+    this.errorCode = response.error;
+    this.details = response.details;
+    this.headers = headers;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Factory: inspect the raw response and construct the most specific subclass.
+   */
+  static fromResponse(response, headers) {
+    switch (response.statusCode) {
+      case 401:
+        return new TchaviAuthenticationError(response, headers);
+      case 402:
+        return new TchaviInsufficientCreditsError(response, headers);
+      case 429:
+        return new TchaviRateLimitError(response, headers);
+      default:
+        return new _TchaviAPIError(response, headers);
+    }
+  }
+};
+
+// src/core/http-client.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 502, 503]);
+var HttpClient = class {
+  baseURL;
+  maxRetries;
+  defaultTimeout;
+  auth;
+  constructor(auth, baseURL, maxRetries, timeout) {
+    this.auth = auth;
+    this.baseURL = baseURL.replace(/\/$/, "");
+    this.maxRetries = maxRetries;
+    this.defaultTimeout = timeout;
+  }
+  async request(options) {
+    const response = await this.requestRaw(options);
+    return response.json();
+  }
+  /**
+   * Returns the raw Response — used for streaming so callers can pipe the body.
+   */
+  async requestRaw(options) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        await this.sleep(this.backoffMs(attempt));
+      }
+      const controller = new AbortController();
+      const timeout = options.timeout ?? this.defaultTimeout;
+      const timerId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const url = this.buildURL(options.path, options.query);
+        const authHeader = options.skipAuth ? void 0 : await this.auth.getAuthHeader();
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (authHeader) {
+          headers["Authorization"] = authHeader;
+        }
+        const fetchOptions = {
+          method: options.method ?? "GET",
+          headers,
+          signal: controller.signal,
+          credentials: "include"
+        };
+        if (options.body !== void 0) {
+          fetchOptions.body = JSON.stringify(options.body);
+        }
+        const response = await fetch(url, fetchOptions);
+        clearTimeout(timerId);
+        if (response.ok) {
+          return response;
+        }
+        if (RETRYABLE_STATUS.has(response.status) && attempt < this.maxRetries) {
+          const retryAfter = response.headers.get("Retry-After");
+          if (retryAfter) {
+            const seconds = parseInt(retryAfter, 10);
+            if (!Number.isNaN(seconds) && seconds > 0) {
+              await this.sleep(seconds * 1e3);
+            }
+          }
+          lastError = new TchaviError(`HTTP ${response.status} ${response.statusText}`);
+          continue;
+        }
+        let errorBody;
+        try {
+          errorBody = await response.json();
+        } catch {
+          errorBody = {
+            error: "unknown_error",
+            message: response.statusText,
+            statusCode: response.status
+          };
+        }
+        const headersObj = {};
+        response.headers.forEach((value, key) => {
+          headersObj[key] = value;
+        });
+        throw TchaviAPIError.fromResponse(errorBody, headersObj);
+      } catch (err) {
+        clearTimeout(timerId);
+        if (err instanceof TchaviAPIError) throw err;
+        if (err.name === "AbortError") {
+          throw new TchaviError(`Request timed out after ${timeout}ms`);
+        }
+        lastError = err;
+        if (attempt === this.maxRetries) {
+          throw new TchaviError(`Network error: ${err.message}`);
+        }
+      }
+    }
+    throw new TchaviError(`Request failed after ${this.maxRetries} retries: ${String(lastError)}`);
+  }
+  buildURL(path, query) {
+    const url = new URL(`${this.baseURL}${path}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  /** Exponential backoff with full jitter */
+  backoffMs(attempt) {
+    const base = 500;
+    const cap = 1e4;
+    const ceiling = Math.min(cap, base * Math.pow(2, attempt));
+    return Math.random() * ceiling;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/core/streaming.ts
+var MAX_BUFFER_SIZE = 1048576;
+async function* parseStream(body) {
+  const reader = 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 });
+      if (buffer.length > MAX_BUFFER_SIZE) {
+        throw new TchaviError(
+          `SSE buffer exceeded ${MAX_BUFFER_SIZE} bytes \u2014 possible malformed stream`
+        );
+      }
+      const events = buffer.split("\n\n");
+      buffer = events.pop() ?? "";
+      for (const rawEvent of events) {
+        const lines = rawEvent.split("\n");
+        let eventType;
+        let dataLine;
+        for (const line of lines) {
+          if (line.startsWith("event: ")) {
+            eventType = line.slice(7).trim();
+          } else if (line.startsWith("data: ")) {
+            dataLine = line.slice(6).trim();
+          }
+        }
+        if (!dataLine) continue;
+        if (dataLine === "[DONE]") {
+          yield { type: "done" };
+          return;
+        }
+        if (eventType === "tchavi") {
+          try {
+            const meta = JSON.parse(dataLine);
+            yield { type: "tchavi", data: meta };
+          } catch {
+          }
+          continue;
+        }
+        try {
+          const parsed = JSON.parse(dataLine);
+          yield { type: "data", data: parsed };
+        } catch {
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+var TchaviStream = class {
+  body;
+  _tchaviMeta = null;
+  constructor(body) {
+    this.body = body;
+  }
+  [Symbol.asyncIterator]() {
+    return this._consume();
+  }
+  async *_consume() {
+    try {
+      for await (const event of parseStream(this.body)) {
+        if (event.type === "data") {
+          yield event.data;
+        } else if (event.type === "tchavi") {
+          this._tchaviMeta = event.data;
+        }
+      }
+    } finally {
+      this.body.cancel().catch(() => {
+      });
+    }
+  }
+  /** Returns Tchavi credit metadata once the stream is fully consumed. */
+  finalMeta() {
+    return this._tchaviMeta;
+  }
+};
+
+// src/resources/chat/completions.ts
+var Completions = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async create(params) {
+    if (params.stream === true) {
+      const response = await this.http.requestRaw({
+        method: "POST",
+        path: "/v1/chat/completions",
+        body: params,
+        timeout: 12e4
+      });
+      if (!response.body) {
+        throw new TchaviError("Streaming response has no body");
+      }
+      return new TchaviStream(response.body);
+    }
+    return this.http.request({
+      method: "POST",
+      path: "/v1/chat/completions",
+      body: params
+    });
+  }
+};
+
+// src/resources/chat/index.ts
+var Chat = class {
+  completions;
+  constructor(http) {
+    this.completions = new Completions(http);
+  }
+};
+
+// src/resources/embeddings.ts
+var Embeddings = class {
+  constructor(http) {
+    this.http = http;
+  }
+  create(params) {
+    return this.http.request({
+      method: "POST",
+      path: "/v1/embeddings",
+      body: params
+    });
+  }
+};
+
+// src/resources/images/generations.ts
+var Generations = class {
+  constructor(http) {
+    this.http = http;
+  }
+  create(params) {
+    return this.http.request({
+      method: "POST",
+      path: "/v1/images/generations",
+      body: params
+    });
+  }
+};
+
+// src/resources/images/index.ts
+var Images = class {
+  generations;
+  constructor(http) {
+    this.generations = new Generations(http);
+  }
+};
+
+// src/resources/credits.ts
+var Credits = class {
+  constructor(http) {
+    this.http = http;
+  }
+  getBalance() {
+    return this.http.request({ path: "/credits/balance" });
+  }
+  listPacks() {
+    return this.http.request({ path: "/credits/packs", skipAuth: true });
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeys = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list() {
+    return this.http.request({ path: "/api-keys" });
+  }
+  create(params = {}) {
+    return this.http.request({ method: "POST", path: "/api-keys", body: params });
+  }
+  retrieve(id) {
+    return this.http.request({ path: `/api-keys/${id}` });
+  }
+  update(id, params) {
+    return this.http.request({ method: "PUT", path: `/api-keys/${id}`, body: params });
+  }
+  delete(id) {
+    return this.http.request({ method: "DELETE", path: `/api-keys/${id}` });
+  }
+};
+
+// src/resources/usage.ts
+var Usage = class {
+  constructor(http) {
+    this.http = http;
+  }
+  getStats(params = {}) {
+    return this.http.request({
+      path: "/usage/stats",
+      query: params
+    });
+  }
+  getHistory(params = {}) {
+    return this.http.request({
+      path: "/usage/history",
+      query: params
+    });
+  }
+};
+
+// src/resources/models.ts
+var Models = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Lists all active model tiers. Pass `all: true` to include inactive ones (admin only). */
+  list(params = {}) {
+    return this.http.request({
+      path: "/model-tiers",
+      query: params.all ? { all: "true" } : void 0,
+      skipAuth: true
+    });
+  }
+};
+
+// src/resources/payments.ts
+var Payments = class {
+  constructor(http) {
+    this.http = http;
+  }
+  initiate(params) {
+    return this.http.request({ method: "POST", path: "/payments/initiate", body: params });
+  }
+  getStatus(id) {
+    return this.http.request({ path: `/payments/status/${id}` });
+  }
+  getHistory(params = {}) {
+    return this.http.request({
+      path: "/payments/history",
+      query: params
+    });
+  }
+};
+
+// src/resources/auth-resource.ts
+var AuthResource = class {
+  constructor(http, authStrategy) {
+    this.http = http;
+    this.authStrategy = authStrategy;
+  }
+  async login(email, password) {
+    const result = await this.http.request({
+      method: "POST",
+      path: "/auth/login",
+      body: { email, password },
+      skipAuth: true
+    });
+    this.authStrategy.setAccessToken(result.accessToken);
+    return result;
+  }
+  register(params) {
+    return this.http.request({
+      method: "POST",
+      path: "/auth/register",
+      body: params,
+      skipAuth: true
+    });
+  }
+  logout() {
+    return this.http.request({ method: "POST", path: "/auth/logout" });
+  }
+};
+
+// src/resources/users.ts
+var Users = class {
+  constructor(http) {
+    this.http = http;
+  }
+  me() {
+    return this.http.request({ path: "/users/me" });
+  }
+  update(params) {
+    return this.http.request({ method: "PUT", path: "/users/me", body: params });
+  }
+};
+
+// src/tchavi.ts
+var DEFAULT_BASE_URL = "http://localhost:3001";
+var DEFAULT_MAX_RETRIES = 2;
+var DEFAULT_TIMEOUT = 6e4;
+var Tchavi = class {
+  chat;
+  embeddings;
+  images;
+  credits;
+  apiKeys;
+  usage;
+  models;
+  payments;
+  auth;
+  users;
+  constructor(options) {
+    const baseURL = options.baseURL ?? DEFAULT_BASE_URL;
+    const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    const authStrategy = new AuthStrategy(options);
+    const http = new HttpClient(authStrategy, baseURL, maxRetries, timeout);
+    this.chat = new Chat(http);
+    this.embeddings = new Embeddings(http);
+    this.images = new Images(http);
+    this.credits = new Credits(http);
+    this.apiKeys = new ApiKeys(http);
+    this.usage = new Usage(http);
+    this.models = new Models(http);
+    this.payments = new Payments(http);
+    this.auth = new AuthResource(http, authStrategy);
+    this.users = new Users(http);
+  }
+};
+
+// src/index.ts
+var index_default = Tchavi;
+
+export { Tchavi, TchaviAPIError, TchaviAuthenticationError, TchaviError, TchaviInsufficientCreditsError, TchaviRateLimitError, TchaviStream, index_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map