@abstraxn/chat-ai/README.md

Abstraxn ChatAI package for Simple and efficient communication with ChatAI API

# ChatAI

## Overview

The Abstraxn ChatAI SDK is a simple and efficient SDK for communicating with the ChatAI API. This SDK provides easy-to-use methods for both streaming and non-streaming chat interactions.

## Installation

```bash
npm install @abstraxn/chat-ai
```

Or using `yarn` package manager:

```bash
yarn add @abstraxn/chat-ai
```

## Quick Start

```typescript
import { ChatAIClient } from "@abstraxn/chat-ai";

const client = new ChatAIClient({
  apiKey: "your-api-key-here",
});

// Simple chat
const response = await client.chat("What is machine learning?");
console.log(response.response);
```

## Features

- **Simple API** - Easy to use with minimal configuration
- **Streaming Support** - Real-time streaming responses with Server-Sent Events
- **Session Management** - Maintain conversation context across requests
- **CORS Support** - Configurable headers for cross-origin requests
- **TypeScript Support** - Full type definitions included
- **Error Handling** - Comprehensive error handling with detailed messages
- **Custom Headers** - Support for additional HTTP headers

## Usage Examples

### Basic Chat (Non-Streaming)

```typescript
import { ChatAIClient } from "@abstraxn/chat-ai";

const client = new ChatAIClient({
  apiKey: "your-api-key",
});

async function basicChat() {
  try {
    const response = await client.chat("What is artificial intelligence?");
    console.log("AI Response:", response.response);
    console.log("Session ID:", response.sessionId);
  } catch (error) {
    console.error("Error:", error.message);
  }
}

basicChat();
```

### Streaming Chat

```typescript
import { ChatAIClient } from "@abstraxn/chat-ai";

const client = new ChatAIClient({
  apiKey: "your-api-key",
});

async function streamingChat() {
  try {
    const stream = await client.chatStream("Explain deep learning in detail");

    for await (const chunk of stream) {
      if (chunk.type === "content") {
        process.stdout.write(chunk.content); // Print streaming content
      }
      if (chunk.type === "done") {
        console.log("\n[Stream complete]");
      }
    }
  } catch (error) {
    console.error("Streaming error:", error.message);
  }
}

streamingChat();
```

### Session Management

```typescript
import { ChatAIClient } from "@abstraxn/chat-ai";

const client = new ChatAIClient({ apiKey: "your-api-key" });

async function conversation() {
  const sessionId = "user-session-123";

  // First message
  const response1 = await client.chat("Hello, my name is John", {
    sessionId: sessionId,
  });
  console.log("AI:", response1.response);

  // Follow-up message (AI will remember the conversation)
  const response2 = await client.chat("What is my name?", {
    sessionId: sessionId,
  });
  console.log("AI:", response2.response);
}
```

### Custom Headers and CORS

```typescript
const client = new ChatAIClient({
  apiKey: "your-api-key",
  origin: "https://my-frontend.com",
  headers: {
    "X-Request-ID": "abc123",
    "X-Client-Version": "1.0.0",
  },
});
```

### Error Handling

```typescript
try {
  const response = await client.chat("Tell me about AI");
  console.log(response.response);
} catch (error) {
  if (error.status) {
    console.error(`API Error ${error.status}:`, error.message);
  } else {
    console.error("Network Error:", error.message);
  }
}
```

## API Reference

### ChatAIClient

#### Constructor

```typescript
new ChatAIClient(config);
```

**Config Options:**

- `apiKey` (required): Your ChatAI API key
- `timeout` (optional): Request timeout in milliseconds (default: `30000`)
- `origin` (optional): Origin header for CORS (default: `*`)
- `headers` (optional): Additional custom headers

#### Methods

##### `chat(query, options)`

Send a chat message and get a complete response.

**Parameters:**

- `query` (string): The message to send
- `options` (object, optional):
  - `sessionId` (string, optional): Session ID for conversation continuity
  - `stream` (boolean, optional): Force non-streaming mode (default: `false`)

**Returns:** Promise<ChatResponse>

##### `chatStream(query, options)`

Send a chat message and get a streaming response.

**Parameters:**

- `query` (string): The message to send
- `options` (object, optional):
  - `sessionId` (string, optional): Session ID for conversation continuity

**Returns:** AsyncGenerator<ChatChunk>

### Types

#### ChatResponse

```typescript
interface ChatResponse {
  error: boolean;
  sessionId: string;
  response: string;
  outOfContext?: boolean;
}
```

#### ChatChunk

```typescript
interface ChatChunk {
  type: "session" | "content" | "done" | "error";
  sessionId?: string;
  content?: string;
  timestamp?: string;
  timing?: {
    total: number;
  };
  outOfContext?: boolean;
  message?: string;
}
```