@codetunezstudios/token-kit 0.1.0-beta.1

package/dist/index.mjs

@@ -0,0 +1,321 @@
+// src/client.ts
+import axios from "axios";
+
+// src/types.ts
+var TokenKitAPIError = class extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.name = "TokenKitAPIError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+
+// src/client.ts
+var TokenKitClient = class {
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key is required");
+    }
+    this.apiKey = config.apiKey;
+    this.client = axios.create({
+      baseURL: config.baseUrl || "https://api.token-kit.com/api/v1",
+      timeout: config.timeout || 6e4,
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      }
+    });
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        return Promise.reject(this.handleError(error));
+      }
+    );
+  }
+  /**
+   * Send a chat completion request
+   */
+  async chat(userToken, messages, options = {}) {
+    try {
+      const response = await this.client.post("/llm/chat", {
+        userToken,
+        messages,
+        model: options.model,
+        maxTokens: options.maxTokens,
+        temperature: options.temperature
+      });
+      if (!response.data.success || !response.data.data) {
+        throw new TokenKitAPIError(
+          response.data.error?.message || "Chat request failed",
+          response.data.error?.code || "CHAT_ERROR",
+          response.status,
+          response.data.error?.details
+        );
+      }
+      return response.data.data;
+    } catch (error) {
+      if (error instanceof TokenKitAPIError) {
+        throw error;
+      }
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Validate a user token
+   */
+  async validateToken(userToken) {
+    try {
+      const response = await this.client.post(
+        "/tokens/validate",
+        { userToken }
+      );
+      if (!response.data.success || !response.data.data) {
+        throw new TokenKitAPIError(
+          response.data.error?.message || "Token validation failed",
+          response.data.error?.code || "VALIDATION_ERROR",
+          response.status,
+          response.data.error?.details
+        );
+      }
+      return response.data.data;
+    } catch (error) {
+      if (error instanceof TokenKitAPIError) {
+        throw error;
+      }
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Get list of available models
+   */
+  async getModels() {
+    try {
+      const response = await this.client.get("/llm/models");
+      if (!response.data.success || !response.data.data) {
+        throw new TokenKitAPIError(
+          response.data.error?.message || "Failed to fetch models",
+          response.data.error?.code || "MODELS_ERROR",
+          response.status,
+          response.data.error?.details
+        );
+      }
+      return response.data.data.models;
+    } catch (error) {
+      if (error instanceof TokenKitAPIError) {
+        throw error;
+      }
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Handle axios errors and convert to TokenKitAPIError
+   */
+  handleError(error) {
+    const isAxios = axios.isAxiosError(error) || typeof error === "object" && error !== null && "isAxiosError" in error;
+    if (isAxios) {
+      const axiosError = error;
+      if (axiosError.code === "ECONNABORTED") {
+        return new TokenKitAPIError(
+          "Request timeout",
+          "TIMEOUT",
+          504
+        );
+      }
+      if (axiosError.code === "ECONNREFUSED" || !axiosError.response) {
+        return new TokenKitAPIError(
+          "Unable to connect to Token-Kit API",
+          "NETWORK_ERROR",
+          503
+        );
+      }
+      if (axiosError.response?.data?.error) {
+        return new TokenKitAPIError(
+          axiosError.response.data.error.message,
+          axiosError.response.data.error.code,
+          axiosError.response.status,
+          axiosError.response.data.error.details
+        );
+      }
+      return new TokenKitAPIError(
+        axiosError.message || "API request failed",
+        "API_ERROR",
+        axiosError.response?.status
+      );
+    }
+    if (error instanceof Error) {
+      return new TokenKitAPIError(
+        error.message,
+        "UNKNOWN_ERROR"
+      );
+    }
+    return new TokenKitAPIError(
+      "An unknown error occurred",
+      "UNKNOWN_ERROR"
+    );
+  }
+};
+
+// src/index.ts
+var TokenKit = class {
+  /**
+   * Create a new TokenKit instance
+   * 
+   * @param config - Configuration options
+   * @param config.apiKey - Your developer API key
+   * @param config.baseUrl - API base URL (optional, defaults to production)
+   * @param config.timeout - Request timeout in ms (optional, defaults to 60000)
+   */
+  constructor(config) {
+    this.userToken = null;
+    this.client = new TokenKitClient(config);
+  }
+  /**
+   * Set the user token for subsequent requests
+   * This allows you to omit the userToken parameter in other methods
+   * 
+   * @param userToken - The user's token
+   */
+  setUserToken(userToken) {
+    this.userToken = userToken;
+  }
+  /**
+   * Send a chat completion request
+   * 
+   * @param userTokenOrMessages - User token string OR array of messages (if user token was set)
+   * @param messagesOrOptions - Array of messages OR chat options (if first param is user token)
+   * @param options - Chat options (only if first two params are provided)
+   * @returns Chat completion response
+   * 
+   * @example
+   * ```typescript
+   * // With explicit user token
+   * const response = await tokenKit.chat('user-token', [
+   *   { role: 'user', content: 'What is Token-Kit?' }
+   * ]);
+   * 
+   * // With pre-set user token
+   * tokenKit.setUserToken('user-token');
+   * const response = await tokenKit.chat([
+   *   { role: 'user', content: 'What is Token-Kit?' }
+   * ]);
+   * 
+   * // With options
+   * const response = await tokenKit.chat('user-token', [
+   *   { role: 'system', content: 'You are a helpful assistant.' },
+   *   { role: 'user', content: 'Hello!' }
+   * ], {
+   *   model: 'gpt-4',
+   *   maxTokens: 200,
+   *   temperature: 0.8
+   * });
+   * ```
+   */
+  async chat(userTokenOrMessages, messagesOrOptions, options) {
+    let userToken;
+    let messages;
+    let chatOptions;
+    if (typeof userTokenOrMessages === "string") {
+      userToken = userTokenOrMessages;
+      messages = messagesOrOptions;
+      chatOptions = options;
+    } else {
+      if (!this.userToken) {
+        throw new Error("User token not set. Call setUserToken() first or pass userToken to chat().");
+      }
+      userToken = this.userToken;
+      messages = userTokenOrMessages;
+      chatOptions = messagesOrOptions;
+    }
+    if (!messages || messages.length === 0) {
+      throw new Error("Messages array cannot be empty");
+    }
+    return this.client.chat(userToken, messages, chatOptions);
+  }
+  /**
+   * Validate a user token and check balance
+   * 
+   * @param userToken - User token to validate (optional if already set)
+   * @returns Token validation response with balance and limits
+   * 
+   * @example
+   * ```typescript
+   * const validation = await tokenKit.validateToken('user-token');
+   * console.log('Balance:', validation.balance);
+   * console.log('Daily spending:', validation.dailySpending);
+   * ```
+   */
+  async validateToken(userToken) {
+    const token = userToken || this.userToken;
+    if (!token) {
+      throw new Error("User token not set. Call setUserToken() first or pass userToken to validateToken().");
+    }
+    return this.client.validateToken(token);
+  }
+  /**
+   * Get balance for the current user token
+   * 
+   * @param userToken - User token (optional if already set)
+   * @returns Current token balance
+   * 
+   * @example
+   * ```typescript
+   * const balance = await tokenKit.getBalance('user-token');
+   * console.log(`You have ${balance} tokens remaining`);
+   * ```
+   */
+  async getBalance(userToken) {
+    const validation = await this.validateToken(userToken);
+    return validation.balance || 0;
+  }
+  /**
+   * Get list of available LLM models
+   * 
+   * @returns Array of model names
+   * 
+   * @example
+   * ```typescript
+   * const models = await tokenKit.getModels();
+   * console.log('Available models:', models);
+   * // ['gpt-3.5-turbo', 'gpt-4', 'gpt-4-turbo']
+   * ```
+   */
+  async getModels() {
+    return this.client.getModels();
+  }
+  /**
+   * Helper method to create a simple user message
+   * 
+   * @param content - Message content
+   * @returns Message object
+   */
+  static user(content) {
+    return { role: "user", content };
+  }
+  /**
+   * Helper method to create a system message
+   * 
+   * @param content - Message content
+   * @returns Message object
+   */
+  static system(content) {
+    return { role: "system", content };
+  }
+  /**
+   * Helper method to create an assistant message
+   * 
+   * @param content - Message content
+   * @returns Message object
+   */
+  static assistant(content) {
+    return { role: "assistant", content };
+  }
+};
+var index_default = TokenKit;
+export {
+  TokenKit,
+  TokenKitAPIError,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,77 @@
+{
+    "name": "@codetunezstudios/token-kit",
+    "version": "0.1.0-beta.1",
+    "description": "Official TypeScript SDK for token-kit - AI token infrastructure for developers",
+    "main": "dist/index.js",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "require": "./dist/index.js",
+            "import": "./dist/index.mjs"
+        }
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+        "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+        "test": "jest",
+        "test:watch": "jest --watch",
+        "typecheck": "tsc --noEmit",
+        "lint": "eslint src --ext .ts",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "token-kit",
+        "ai",
+        "llm",
+        "openai",
+        "gpt",
+        "claude",
+        "gemini",
+        "tokens",
+        "sdk",
+        "typescript",
+        "ai-tokens",
+        "pay-per-use",
+        "developer-tools",
+        "api"
+    ],
+    "author": "Codetunez Studios",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/codetunez-studios/token-kit"
+    },
+    "bugs": {
+        "url": "https://github.com/codetunez-studios/token-kit/issues"
+    },
+    "homepage": "https://token-kit.com",
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {
+        "axios": "^1.6.5"
+    },
+    "devDependencies": {
+        "@types/express": "^5.0.6",
+        "@types/jest": "^29.5.11",
+        "@types/node": "^20.10.6",
+        "@typescript-eslint/eslint-plugin": "^6.17.0",
+        "@typescript-eslint/parser": "^6.17.0",
+        "eslint": "^8.56.0",
+        "express": "^5.2.1",
+        "jest": "^29.7.0",
+        "ts-jest": "^29.1.1",
+        "tsup": "^8.0.1",
+        "typescript": "^5.3.3"
+    },
+    "engines": {
+        "node": ">=18"
+    }
+}