edgee 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,9 @@
-# Edgee Gateway SDK
+# Edgee TypeScript SDK
 
-Lightweight TypeScript SDK for Edgee AI Gateway.
+Lightweight, type-safe TypeScript SDK for the [Edgee AI Gateway](https://www.edgee.cloud).
+
+[![npm version](https://img.shields.io/npm/v/edgee.svg)](https://www.npmjs.com/package/edgee)
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
 
 ## Installation
 
@@ -8,88 +11,76 @@ Lightweight TypeScript SDK for Edgee AI Gateway.
 npm install edgee
 ```
 
-## Usage
+## Quick Start
 
 ```typescript
-import Edgee from "edgee";
-
-const edgee = new Edgee(process.env.EDGEE_API_KEY);
-```
+import Edgee from 'edgee';
 
-### Simple Input
+const edgee = new Edgee("your-api-key");
 
-```typescript
+// Send a simple request
 const response = await edgee.send({
-  model: "gpt-4o",
-  input: "What is the capital of France?",
+  model: 'gpt-4o',
+  input: 'What is the capital of France?',
 });
 
-console.log(response.choices[0].message.content);
+console.log(response.text);
+// "The capital of France is Paris."
 ```
 
-### Full Input with Messages
-
-```typescript
-const response = await edgee.send({
-  model: "gpt-4o",
-  input: {
-    messages: [
-      { role: "system", content: "You are a helpful assistant." },
-      { role: "user", content: "Hello!" },
-    ],
-  },
-});
-```
+## Send Method
 
-### With Tools
+The `send()` method makes non-streaming chat completion requests:
 
 ```typescript
 const response = await edgee.send({
-  model: "gpt-4o",
-  input: {
-    messages: [{ role: "user", content: "What's the weather in Paris?" }],
-    tools: [
-      {
-        type: "function",
-        function: {
-          name: "get_weather",
-          description: "Get weather for a location",
-          parameters: {
-            type: "object",
-            properties: {
-              location: { type: "string" },
-            },
-          },
-        },
-      },
-    ],
-    tool_choice: "auto",
-  },
+  model: 'gpt-4o',
+  input: 'Hello, world!',
 });
 
-if (response.choices[0].message.tool_calls) {
-  console.log(response.choices[0].message.tool_calls);
-}
+// Access response
+console.log(response.text);           // Text content
+console.log(response.finishReason);   // Finish reason
+console.log(response.toolCalls);      // Tool calls (if any)
 ```
 
-## Response
+## Stream Method
+
+The `stream()` method enables real-time streaming responses:
 
 ```typescript
-interface SendResponse {
-  choices: {
-    index: number;
-    message: {
-      role: string;
-      content: string | null;
-      tool_calls?: ToolCall[];
-    };
-    finish_reason: string | null;
-  }[];
-  usage?: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-  };
+for await (const chunk of edgee.stream('gpt-4o', 'Tell me a story')) {
+  if (chunk.text) {
+    process.stdout.write(chunk.text);
+  }
+  
+  if (chunk.finishReason) {
+    console.log(`\nFinished: ${chunk.finishReason}`);
+  }
 }
 ```
 
+## Features
+
+- ✅ **Type-safe** - Full TypeScript support with comprehensive types
+- ✅ **OpenAI-compatible** - Works with any model supported by Edgee
+- ✅ **Streaming** - Real-time response streaming
+- ✅ **Tool calling** - Full support for function calling
+- ✅ **Flexible input** - Accept strings or structured objects
+- ✅ **Zero dependencies** - Lightweight and fast
+
+## Documentation
+
+For complete documentation, examples, and API reference, visit:
+
+**👉 [Official TypeScript SDK Documentation](https://www.edgee.cloud/docs/sdk/typescript)**
+
+The documentation includes:
+- [Configuration guide](https://www.edgee.cloud/docs/sdk/typescript/configuration) - Multiple ways to configure the SDK
+- [Send method](https://www.edgee.cloud/docs/sdk/typescript/send) - Complete guide to non-streaming requests
+- [Stream method](https://www.edgee.cloud/docs/sdk/typescript/stream) - Streaming responses guide
+- [Tools](https://www.edgee.cloud/docs/sdk/typescript/tools) - Function calling guide
+
+## License
+
+Licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for details.

package/dist/index.d.ts

@@ -47,17 +47,53 @@ export interface Choice {
     };
     finish_reason: string | null;
 }
-export interface SendResponse {
+export declare class SendResponse {
     choices: Choice[];
     usage?: {
         prompt_tokens: number;
         completion_tokens: number;
         total_tokens: number;
     };
+    constructor(choices: Choice[], usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    });
+    get text(): string | null;
+    get message(): {
+        role: string;
+        content: string | null;
+        tool_calls?: ToolCall[];
+    };
+    get finishReason(): string | null;
+    get toolCalls(): ToolCall[] | null;
+}
+export interface StreamDelta {
+    role?: string;
+    content?: string;
+    tool_calls?: ToolCall[];
+}
+export interface StreamChoice {
+    index: number;
+    delta: StreamDelta;
+    finish_reason?: string | null;
+}
+export declare class StreamChunk {
+    choices: StreamChoice[];
+    constructor(choices: StreamChoice[]);
+    get text(): string | null;
+    get role(): string | null;
+    get finishReason(): string | null;
+}
+export interface EdgeeConfig {
+    apiKey?: string;
+    baseUrl?: string;
 }
 export default class Edgee {
     private apiKey;
     private baseUrl;
-    constructor(apiKey?: string);
+    constructor(config?: string | EdgeeConfig);
     send(options: SendOptions): Promise<SendResponse>;
+    private _handleStreamingResponse;
+    stream(model: string, input: string | InputObject): AsyncGenerator<StreamChunk>;
 }

package/dist/index.js

@@ -1,10 +1,65 @@
+export class SendResponse {
+    constructor(choices, usage) {
+        this.choices = choices;
+        this.usage = usage;
+    }
+    get text() {
+        if (this.choices[0]?.message?.content) {
+            return this.choices[0].message.content;
+        }
+        return null;
+    }
+    get message() {
+        return this.choices[0]?.message ?? null;
+    }
+    get finishReason() {
+        return this.choices[0]?.finish_reason ?? null;
+    }
+    get toolCalls() {
+        return this.choices[0]?.message?.tool_calls ?? null;
+    }
+}
+export class StreamChunk {
+    constructor(choices) {
+        this.choices = choices;
+    }
+    get text() {
+        if (this.choices[0]?.delta?.content) {
+            return this.choices[0].delta.content;
+        }
+        return null;
+    }
+    get role() {
+        if (this.choices[0]?.delta?.role) {
+            return this.choices[0].delta.role;
+        }
+        return null;
+    }
+    get finishReason() {
+        if (this.choices[0]?.finish_reason) {
+            return this.choices[0].finish_reason;
+        }
+        return null;
+    }
+}
 export default class Edgee {
-    constructor(apiKey) {
-        this.baseUrl = "https://api.edgee.ai";
+    constructor(config) {
+        let apiKey;
+        let baseUrl;
+        if (typeof config === "string") {
+            // Backward compatibility: accept apiKey as string
+            apiKey = config;
+        }
+        else if (config) {
+            // New format: accept config object
+            apiKey = config.apiKey;
+            baseUrl = config.baseUrl;
+        }
         this.apiKey = apiKey || process.env.EDGEE_API_KEY || "";
         if (!this.apiKey) {
             throw new Error("EDGEE_API_KEY is not set");
         }
+        this.baseUrl = baseUrl || process.env.EDGEE_BASE_URL || "https://api.edgee.ai";
     }
     async send(options) {
         const { input } = options;
@@ -28,10 +83,73 @@ export default class Edgee {
             },
             body: JSON.stringify(body),
         });
-        const data = (await res.json());
-        return {
-            choices: data.choices,
-            usage: data.usage,
+        if (!res.ok) {
+            const errorBody = await res.text();
+            throw new Error(`API error ${res.status}: ${errorBody}`);
+        }
+        const data = await res.json();
+        return new SendResponse(data.choices, data.usage);
+    }
+    async *_handleStreamingResponse(url, body) {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const errorBody = await res.text();
+            throw new Error(`API error ${res.status}: ${errorBody}`);
+        }
+        if (!res.body) {
+            throw new Error("Response body is null");
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed === "" || !trimmed.startsWith("data: ")) {
+                    continue;
+                }
+                const data = trimmed.slice(6);
+                if (data === "[DONE]") {
+                    return;
+                }
+                try {
+                    const parsed = JSON.parse(data);
+                    yield new StreamChunk(parsed.choices);
+                }
+                catch {
+                    // Skip malformed JSON
+                    continue;
+                }
+            }
+        }
+    }
+    async *stream(model, input) {
+        const body = {
+            model,
+            messages: typeof input === "string"
+                ? [{ role: "user", content: input }]
+                : input.messages,
+            stream: true,
         };
+        if (typeof input !== "string") {
+            if (input.tools)
+                body.tools = input.tools;
+            if (input.tool_choice)
+                body.tool_choice = input.tool_choice;
+        }
+        yield* this._handleStreamingResponse(`${this.baseUrl}/v1/chat/completions`, body);
     }
 }

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "edgee",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/edgee-cloud/typescript-sdk"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",