sylix 4.2.2 → 4.2.3

package/README.md

@@ -1,221 +1,136 @@
-# Sylix SDK
+# Sylix Node.js SDK
 
-The official SDK for Charles AI models. OpenAI-compatible API for seamless integration.
+[![npm version](https://img.shields.io/npm/v/sylix.svg)](https://www.npmjs.com/package/sylix)
+[![npm downloads](https://img.shields.io/npm/dm/sylix.svg)](https://www.npmjs.com/package/sylix)
+[![License](https://img.shields.io/badge/license-Proprietary-blue.svg)](LICENSE)
 
-**Version:** 1.0.1 | **License:** Proprietary | **Status:** Production Ready
+The official Node.js/TypeScript library for the Sylix AI API, providing convenient access to Charles AI models from Node.js applications.
 
----
-
-## Table of Contents
-
-- [Installation](#installation)
-- [Quick Start](#quick-start)
-- [Charles API](#charles-api)
-- [Available Models](#available-models)
-- [Examples](#examples)
-- [Error Handling](#error-handling)
-- [Configuration](#configuration)
-- [API Reference](#api-reference)
-
----
+> ⚠️ **Important:** This library is intended for server-side usage only. Using it in client-side browser code will expose your API key.
 
 ## Installation
 
 ```bash
-npm install @sylix/sdk
+npm install sylix
 ```
 
-**Requirements:** Node.js 18.0.0 or higher
-
----
-
-## Quick Start
+**Requirements:** Node.js 18+
 
-### Initialize
+## Usage
 
 ```typescript
-import { Sylix, CHARLES_MODELS } from "@sylix/sdk";
+import Sylix from 'sylix';
 
-const sylix = new Sylix({
-  apiKey: process.env.SYLIX_API_KEY
+const client = new Sylix({
+  apiKey: process.env['SYLIX_API_KEY'], // This is the default and can be omitted
 });
-```
 
-### Chat Completion
+async function main() {
+  const response = await client.charles.chat.completions.create({
+    model: 'charles-s1:latest',
+    messages: [{ role: 'user', content: 'Hello, Charles!' }],
+  });
 
-```typescript
-const response = await sylix.charles.chat.completions.create({
-  model: CHARLES_MODELS.MINI,
-  messages: [
-    { role: "system", content: "You are a helpful assistant." },
-    { role: "user", content: "Hello!" }
-  ]
-});
+  console.log(response.choices[0].message.content);
+}
 
-console.log(response.choices[0].message.content);
+main();
 ```
 
-### List Models
+## Streaming
 
-```typescript
-const models = await sylix.charles.models.list();
-```
-
-### Generate Embeddings
+We support streaming responses using Server Sent Events (SSE):
 
 ```typescript
-const result = await sylix.charles.embeddings.create({
-  model: CHARLES_MODELS.MINI,
-  input: "Hello world"
-});
-```
+import Sylix from 'sylix';
 
----
+const client = new Sylix();
 
-## Charles API
-
-The Charles namespace provides OpenAI-compatible endpoints.
+async function main() {
+  const stream = await client.charles.chat.completions.create({
+    model: 'charles-s1:latest',
+    messages: [{ role: 'user', content: 'Write a short poem' }],
+    stream: true,
+  });
 
-### Chat Completions
+  for await (const chunk of stream) {
+    process.stdout.write(chunk.choices[0]?.delta?.content || '');
+  }
+}
 
-```typescript
-sylix.charles.chat.completions.create(options)
+main();
 ```
 
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| `model` | `string` | Yes | Model ID |
-| `messages` | `ChatMessage[]` | Yes | Conversation messages |
-| `temperature` | `number` | No | Sampling temperature (0-2) |
-| `max_tokens` | `number` | No | Maximum tokens in response |
-| `stream` | `boolean` | No | Enable streaming |
-| `tools` | `Tool[]` | No | Function calling tools |
-| `tool_choice` | `string` | No | Tool selection mode |
+## Request & Response Types
 
-### Models
+This library includes TypeScript definitions for all request params and response fields:
 
 ```typescript
-// List all models
-const models = await sylix.charles.models.list();
+import Sylix from 'sylix';
+import { ChatRequest, ChatResponse, ChatMessage } from 'sylix';
 
-// Retrieve specific model
-const model = await sylix.charles.models.retrieve("charles-mini");
-```
-
-### Embeddings
-
-```typescript
-const result = await sylix.charles.embeddings.create({
-  model: "charles-mini:latest",
-  input: "Text to embed"
-});
-```
-
----
-
-## Available Models
-
-| Model | ID | Tier | Description |
-|-------|-----|------|-------------|
-| Charles Mini | `charles-mini:latest` | Free | Lightweight, fast responses |
-| Charles S1 | `charles-s1:latest` | Standard | Reasoning and code generation |
-| Charles V1 | `charles-v1:latest` | Advanced | Complex analysis |
-| Charles 2.9 | `charles-2.9:latest` | Premium | State-of-the-art performance |
-| Charles R1 | `charles-r1:latest` | Premium | Advanced reasoning |
+const client = new Sylix();
 
-### Model Constants
+const messages: ChatMessage[] = [
+  { role: 'system', content: 'You are a helpful assistant.' },
+  { role: 'user', content: 'What is TypeScript?' },
+];
 
-```typescript
-import { CHARLES_MODELS } from "@sylix/sdk";
+const params: ChatRequest = {
+  model: 'charles-s1:latest',
+  messages,
+  temperature: 0.7,
+};
 
-CHARLES_MODELS.MINI   // "charles-mini:latest"
-CHARLES_MODELS.S1     // "charles-s1:latest"
-CHARLES_MODELS.V1     // "charles-v1:latest"
-CHARLES_MODELS.V2_9   // "charles-2.9:latest"
+const response: ChatResponse = await client.charles.chat.completions.create(params);
 ```
 
----
-
-## Examples
+## Available Models
 
-### Multi-turn Conversation
+| Model | ID | Description |
+|-------|-----|-------------|
+| Charles Mini | `charles-mini:latest` | Lightweight, fast responses |
+| Charles S1 | `charles-s1:latest` | Balanced performance for coding |
+| Charles V1 | `charles-v1:latest` | Advanced reasoning capabilities |
+| Charles 2.9 | `charles-2.9:latest` | State-of-the-art performance |
+| Charles R1 | `charles-r1:latest` | Deep reasoning and analysis |
 
 ```typescript
-const messages = [
-  { role: "system", content: "You are a coding assistant." },
-  { role: "user", content: "Write hello world in Python" }
-];
-
-const response = await sylix.charles.chat.completions.create({
-  model: CHARLES_MODELS.S1,
-  messages
-});
-
-messages.push(response.choices[0].message);
-messages.push({ role: "user", content: "Now in Rust" });
-
-const followUp = await sylix.charles.chat.completions.create({
-  model: CHARLES_MODELS.S1,
-  messages
-});
-```
-
-### Function Calling
+import { CHARLES_MODELS } from 'sylix';
 
-```typescript
-const response = await sylix.charles.chat.completions.create({
-  model: CHARLES_MODELS.V1,
-  messages: [{ role: "user", content: "What is the weather in Tokyo?" }],
-  tools: [{
-    type: "function",
-    function: {
-      name: "get_weather",
-      description: "Get weather for a location",
-      parameters: {
-        type: "object",
-        properties: {
-          location: { type: "string" }
-        },
-        required: ["location"]
-      }
-    }
-  }],
-  tool_choice: "auto"
+// Use model constants for type safety
+const response = await client.charles.chat.completions.create({
+  model: CHARLES_MODELS.S1, // 'charles-s1:latest'
+  messages: [{ role: 'user', content: 'Hello!' }],
 });
 ```
 
-### Batch Processing
+## Handling Errors
 
-```typescript
-const prompts = ["What is AI?", "Explain ML", "Define DL"];
-
-const responses = await Promise.all(
-  prompts.map(prompt =>
-    sylix.charles.chat.completions.create({
-      model: CHARLES_MODELS.MINI,
-      messages: [{ role: "user", content: prompt }]
-    })
-  )
-);
-```
-
----
-
-## Error Handling
+When the API returns a non-success status code, an error is thrown:
 
 ```typescript
-import { Sylix, SylixError } from "@sylix/sdk";
-
-try {
-  const response = await sylix.charles.chat.completions.create({
-    model: "invalid-model",
-    messages: [{ role: "user", content: "Hello" }]
-  });
-} catch (error) {
-  if (error instanceof SylixError) {
-    console.error(`[${error.code}] ${error.message}`);
+import Sylix, { SylixError } from 'sylix';
+
+const client = new Sylix();
+
+async function main() {
+  try {
+    const response = await client.charles.chat.completions.create({
+      model: 'invalid-model',
+      messages: [{ role: 'user', content: 'Hello' }],
+    });
+  } catch (err) {
+    if (err instanceof SylixError) {
+      console.log(err.code);    // e.g., 'INVALID_MODEL'
+      console.log(err.message); // Detailed error message
+    } else {
+      throw err;
+    }
   }
 }
+
+main();
 ```
 
 ### Error Codes
@@ -223,135 +138,125 @@ try {
 | Code | Description |
 |------|-------------|
 | `MISSING_API_KEY` | API key not provided |
-| `INVALID_MODEL` | Model not found |
-| `invalid_api_key` | Invalid or expired API key |
-| `model_backend_error` | Model backend unavailable |
-| `internal_error` | Internal server error |
+| `INVALID_MODEL` | Model not found or unavailable |
+| `INVALID_API_KEY` | Invalid or expired API key |
+| `RATE_LIMIT_ERROR` | Too many requests |
+| `STREAM_ERROR` | Streaming connection error |
+| `NETWORK_ERROR` | Network connectivity issue |
 
----
+## Retries
 
-## Configuration
+The library automatically retries on connection errors, 408, 429, and 5XX status codes. You can configure this:
 
 ```typescript
-interface SylixConfig {
-  apiKey: string;                    // Required
-  baseURL?: string;                  // Default: https://api.sylixide.com/v1
-  timeout?: number;                  // Default: 30000 (ms)
-  headers?: Record<string, string>;  // Custom headers
-}
-
-const sylix = new Sylix({
-  apiKey: process.env.SYLIX_API_KEY,
-  baseURL: "https://api.sylixide.com/v1",
-  timeout: 60000
+const client = new Sylix({
+  maxRetries: 2, // default is 4
+  timeout: 30000, // default is 30 seconds
 });
 ```
 
-### Security
-
-Store API keys in environment variables:
+## Function Calling
 
 ```typescript
-// Recommended
-const sylix = new Sylix({ apiKey: process.env.SYLIX_API_KEY });
+const response = await client.charles.chat.completions.create({
+  model: 'charles-v1:latest',
+  messages: [{ role: 'user', content: 'What is the weather in Tokyo?' }],
+  tools: [
+    {
+      type: 'function',
+      function: {
+        name: 'get_weather',
+        description: 'Get current weather for a location',
+        parameters: {
+          type: 'object',
+          properties: {
+            location: { type: 'string', description: 'City name' },
+          },
+          required: ['location'],
+        },
+      },
+    },
+  ],
+  tool_choice: 'auto',
+});
 
-// Not recommended
-const sylix = new Sylix({ apiKey: "sk-..." });
+// Check if the model wants to call a function
+if (response.choices[0].message.tool_calls) {
+  const toolCall = response.choices[0].message.tool_calls[0];
+  console.log('Function:', toolCall.function.name);
+  console.log('Arguments:', toolCall.function.arguments);
+}
 ```
 
----
+## Embeddings
 
-## API Reference
-
-For complete API documentation, see [API_REFERENCE.md](./API_REFERENCE.md).
-
-### Types
+Generate vector embeddings for text:
 
 ```typescript
-// Chat message
-interface ChatMessage {
-  role: "system" | "user" | "assistant";
-  content: string;
-}
-
-// Chat response
-interface ChatResponse {
-  id: string;
-  object: "chat.completion";
-  created: number;
-  model: string;
-  choices: Array<{
-    index: number;
-    message: ChatMessage;
-    finish_reason: string;
-  }>;
-  usage: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-  };
-}
+const response = await client.charles.embeddings.create({
+  model: 'charles-mini:latest',
+  input: 'The quick brown fox jumps over the lazy dog',
+});
 
-// Model
-interface CharlesModel {
-  id: string;
-  object: "model";
-  created: number;
-  owned_by: "sylix";
-}
+console.log(response.data[0].embedding); // Vector array
 ```
 
----
-
-## Development
+## Models API
 
-### Build
+```typescript
+// List all available models
+const models = await client.charles.models.list();
+console.log(models.data);
 
-```bash
-npm install
-npm run build
-npm test
+// Get a specific model
+const model = await client.charles.models.retrieve('charles-s1:latest');
+console.log(model);
 ```
 
-### Project Structure
+## Configuration
 
-```
-sylix-sdk/
-├── src/
-│   ├── index.ts      # Main exports
-│   ├── types.ts      # TypeScript types
-│   ├── client.ts     # HTTP client
-│   └── utils.ts      # Utilities
-├── dist/             # Compiled output
-└── API_REFERENCE.md  # API documentation
+```typescript
+import Sylix from 'sylix';
+
+const client = new Sylix({
+  apiKey: process.env['SYLIX_API_KEY'], // Required
+  baseURL: 'https://api.sylixide.com/v1', // Default
+  timeout: 60000, // Request timeout in ms
+  maxRetries: 4, // Retry attempts for failed requests
+});
 ```
 
----
+### Environment Variables
 
-## Contributing
+| Variable | Description |
+|----------|-------------|
+| `SYLIX_API_KEY` | Your Sylix API key |
+| `SYLIX_BASE_URL` | Override the default base URL |
 
-1. Fork the repository
-2. Create a feature branch
-3. Commit changes
-4. Submit a pull request
+## Semantic Versioning
 
----
+This package follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions.
 
-## License
+We recommend pinning to a specific version and upgrading periodically:
 
-Proprietary License. Copyright 2026 Sylix. All rights reserved.
+```bash
+npm install sylix@4.2.2
+```
 
-This software is proprietary and confidential. Unauthorized copying, distribution, or modification is strictly prohibited.
+## Requirements
 
----
+- Node.js 18 or higher
+- TypeScript 4.7+ (for TypeScript users)
 
 ## Support
 
-- **Documentation:** [API_REFERENCE.md](./API_REFERENCE.md)
+- **Documentation:** [docs.sylixide.com](https://docs.sylixide.com)
+- **API Reference:** [api.sylixide.com](https://api.sylixide.com)
 - **Issues:** [GitHub Issues](https://github.com/Curly-09/sylix-ide-sdk/issues)
-- **Website:** [sylixide.com](https://sylixide.com)
-- **Email:** support@sylixide.com
+- **Email:** [support@sylixide.com](mailto:support@sylixide.com)
+
+## License
 
----
+Proprietary License © 2026 Sylix Technologies. All rights reserved.
 
-Sylix SDK - Built for developers.
+See [LICENSE](LICENSE) for details.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sylix",
-  "version": "4.2.2",
+  "version": "4.2.3",
   "description": "The official Sylix AI SDK for TypeScript and JavaScript. Build intelligent applications with Charles v3 models featuring multi-model consensus, intelligent routing, vision understanding, deep reasoning, and OpenAI-compatible APIs. Enterprise-grade AI infrastructure for developers.",
   "type": "module",
   "main": "./dist/index.js",