@radkod/ai 0.1.0

package/README.md

@@ -0,0 +1,156 @@
+# @radkod/ai
+
+Lightweight SDK for RadKod AI API — OpenAI-compatible LLM proxy with streaming and tool calling.
+
+## Install
+
+```bash
+npm install @radkod/ai
+```
+
+## Quick Start
+
+```typescript
+import { RadKodAI } from '@radkod/ai'
+
+const ai = new RadKodAI({
+  baseUrl: 'https://ai.radkod.com',
+  apiKey: 'benv-your-key-here'
+})
+
+// Simple prompt
+const answer = await ai.prompt('What is quantum computing?')
+console.log(answer)
+```
+
+## Streaming
+
+```typescript
+await ai.promptStream('Count to 10', (token) => {
+  process.stdout.write(token)
+})
+```
+
+Or with full control:
+
+```typescript
+const result = await ai.chatStream(
+  {
+    model: 'z-ai/glm4.7',
+    messages: [{ role: 'user', content: 'Hello!' }]
+  },
+  {
+    onToken: (token) => process.stdout.write(token),
+    onDone: (fullText) => console.log('\n\nDone:', fullText.length, 'chars'),
+    onError: (err) => console.error('Error:', err)
+  }
+)
+```
+
+## Tool Calling
+
+Define tools and handlers — the SDK runs the tool loop automatically:
+
+```typescript
+const result = await ai.chatWithTools(
+  {
+    messages: [{ role: 'user', content: 'What is the weather in Istanbul?' }],
+    tools: [
+      {
+        type: 'function',
+        function: {
+          name: 'get_weather',
+          description: 'Get current weather for a city',
+          parameters: {
+            type: 'object',
+            properties: {
+              city: { type: 'string', description: 'City name' }
+            },
+            required: ['city']
+          }
+        }
+      }
+    ]
+  },
+  {
+    get_weather: async ({ city }) => {
+      // Your tool implementation
+      return { temperature: 22, condition: 'sunny', city }
+    }
+  }
+)
+
+console.log(result.finalText) // "The weather in Istanbul is 22°C and sunny."
+```
+
+## Full Chat API
+
+```typescript
+const response = await ai.chat({
+  model: 'meta/llama-3.3-70b-instruct',
+  messages: [
+    { role: 'system', content: 'You are a helpful assistant.' },
+    { role: 'user', content: 'Explain REST vs GraphQL' }
+  ],
+  temperature: 0.7,
+  max_tokens: 2000
+})
+
+console.log(response.choices[0].message.content)
+```
+
+## List Models
+
+```typescript
+const models = await ai.models()
+models.forEach(m => console.log(m.id, '—', m.owned_by))
+```
+
+## Health Check
+
+```typescript
+const health = await ai.health()
+console.log(health.status) // "ok"
+```
+
+## Browser Usage
+
+```html
+<script type="module">
+  import { RadKodAI } from 'https://cdn.jsdelivr.net/npm/@radkod/ai/dist/index.mjs'
+
+  const ai = new RadKodAI({ apiKey: 'benv-xxx' })
+  const answer = await ai.prompt('Hello!')
+  document.body.textContent = answer
+</script>
+```
+
+## Configuration
+
+```typescript
+const ai = new RadKodAI({
+  baseUrl: 'https://ai.radkod.com', // API server URL
+  apiKey: 'benv-xxx',               // API key (optional in open mode)
+  defaultModel: 'z-ai/glm4.7',     // Default model for all requests
+  timeout: 300000                    // Request timeout in ms (default: 5min)
+})
+```
+
+## Error Handling
+
+```typescript
+import { RadKodAI, RadKodError } from '@radkod/ai'
+
+try {
+  await ai.prompt('Hello')
+} catch (err) {
+  if (err instanceof RadKodError) {
+    console.log(err.status) // 401, 429, 502, etc.
+    console.log(err.body)   // API error response body
+  }
+}
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,130 @@
+interface RadKodConfig {
+    baseUrl?: string;
+    apiKey?: string;
+    defaultModel?: string;
+    timeout?: number;
+}
+interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[];
+}
+interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface ChatOptions {
+    model?: string;
+    messages: ChatMessage[];
+    stream?: boolean;
+    tools?: ToolDefinition[];
+    tool_choice?: 'auto' | 'none' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    seed?: number;
+}
+interface ChatResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        message: ChatMessage;
+        finish_reason: string | null;
+    }[];
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+interface StreamChunk {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        delta: {
+            role?: string;
+            content?: string;
+            tool_calls?: {
+                index: number;
+                id?: string;
+                type?: string;
+                function?: {
+                    name?: string;
+                    arguments?: string;
+                };
+            }[];
+        };
+        finish_reason: string | null;
+    }[];
+}
+interface Model {
+    id: string;
+    object: string;
+    created: number;
+    owned_by: string;
+}
+interface StreamCallbacks {
+    onToken?: (token: string) => void;
+    onToolCall?: (toolCall: ToolCall) => void;
+    onDone?: (fullText: string) => void;
+    onError?: (error: Error) => void;
+}
+interface ChatStreamResult {
+    text: string;
+    toolCalls: ToolCall[];
+}
+declare class RadKodError extends Error {
+    status: number;
+    body: unknown;
+    constructor(message: string, status: number, body?: unknown);
+}
+declare class RadKodAI {
+    private baseUrl;
+    private apiKey;
+    private defaultModel;
+    private timeout;
+    constructor(config?: RadKodConfig);
+    private headers;
+    private request;
+    health(): Promise<{
+        status: string;
+    }>;
+    models(): Promise<Model[]>;
+    chat(options: ChatOptions): Promise<ChatResponse>;
+    chatStream(options: ChatOptions, callbacks?: StreamCallbacks): Promise<ChatStreamResult>;
+    prompt(text: string, model?: string): Promise<string>;
+    promptStream(text: string, onToken: (token: string) => void, model?: string): Promise<string>;
+    chatWithTools(options: ChatOptions & {
+        tools: ToolDefinition[];
+    }, toolHandlers: Record<string, (args: unknown) => unknown | Promise<unknown>>, maxRounds?: number): Promise<{
+        messages: ChatMessage[];
+        finalText: string;
+    }>;
+}
+
+export { type ChatMessage, type ChatOptions, type ChatResponse, type ChatStreamResult, type Model, RadKodAI, type RadKodConfig, RadKodError, type StreamCallbacks, type StreamChunk, type ToolCall, type ToolDefinition, RadKodAI as default };

package/dist/index.d.ts

@@ -0,0 +1,130 @@
+interface RadKodConfig {
+    baseUrl?: string;
+    apiKey?: string;
+    defaultModel?: string;
+    timeout?: number;
+}
+interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[];
+}
+interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface ChatOptions {
+    model?: string;
+    messages: ChatMessage[];
+    stream?: boolean;
+    tools?: ToolDefinition[];
+    tool_choice?: 'auto' | 'none' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    seed?: number;
+}
+interface ChatResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        message: ChatMessage;
+        finish_reason: string | null;
+    }[];
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+interface StreamChunk {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        delta: {
+            role?: string;
+            content?: string;
+            tool_calls?: {
+                index: number;
+                id?: string;
+                type?: string;
+                function?: {
+                    name?: string;
+                    arguments?: string;
+                };
+            }[];
+        };
+        finish_reason: string | null;
+    }[];
+}
+interface Model {
+    id: string;
+    object: string;
+    created: number;
+    owned_by: string;
+}
+interface StreamCallbacks {
+    onToken?: (token: string) => void;
+    onToolCall?: (toolCall: ToolCall) => void;
+    onDone?: (fullText: string) => void;
+    onError?: (error: Error) => void;
+}
+interface ChatStreamResult {
+    text: string;
+    toolCalls: ToolCall[];
+}
+declare class RadKodError extends Error {
+    status: number;
+    body: unknown;
+    constructor(message: string, status: number, body?: unknown);
+}
+declare class RadKodAI {
+    private baseUrl;
+    private apiKey;
+    private defaultModel;
+    private timeout;
+    constructor(config?: RadKodConfig);
+    private headers;
+    private request;
+    health(): Promise<{
+        status: string;
+    }>;
+    models(): Promise<Model[]>;
+    chat(options: ChatOptions): Promise<ChatResponse>;
+    chatStream(options: ChatOptions, callbacks?: StreamCallbacks): Promise<ChatStreamResult>;
+    prompt(text: string, model?: string): Promise<string>;
+    promptStream(text: string, onToken: (token: string) => void, model?: string): Promise<string>;
+    chatWithTools(options: ChatOptions & {
+        tools: ToolDefinition[];
+    }, toolHandlers: Record<string, (args: unknown) => unknown | Promise<unknown>>, maxRounds?: number): Promise<{
+        messages: ChatMessage[];
+        finalText: string;
+    }>;
+}
+
+export { type ChatMessage, type ChatOptions, type ChatResponse, type ChatStreamResult, type Model, RadKodAI, type RadKodConfig, RadKodError, type StreamCallbacks, type StreamChunk, type ToolCall, type ToolDefinition, RadKodAI as default };

package/dist/index.js

@@ -0,0 +1,259 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  RadKodAI: () => RadKodAI,
+  RadKodError: () => RadKodError,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var RadKodError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.name = "RadKodError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var RadKodAI = class {
+  constructor(config = {}) {
+    this.baseUrl = (config.baseUrl || "https://ai.radkod.com").replace(/\/$/, "");
+    this.apiKey = config.apiKey || "";
+    this.defaultModel = config.defaultModel || "z-ai/glm4.7";
+    this.timeout = config.timeout || 3e5;
+  }
+  // ── Headers ─────────────────────────────────────────────────
+  headers() {
+    const h = { "Content-Type": "application/json" };
+    if (this.apiKey) h["Authorization"] = `Bearer ${this.apiKey}`;
+    return h;
+  }
+  async request(path, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const resp = await fetch(`${this.baseUrl}${path}`, {
+        ...init,
+        headers: { ...this.headers(), ...init?.headers },
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!resp.ok) {
+        let body;
+        try {
+          body = await resp.json();
+        } catch {
+          body = await resp.text();
+        }
+        throw new RadKodError(
+          `API error ${resp.status}: ${typeof body === "string" ? body : JSON.stringify(body)}`,
+          resp.status,
+          body
+        );
+      }
+      return await resp.json();
+    } catch (err) {
+      clearTimeout(timer);
+      if (err instanceof RadKodError) throw err;
+      throw new RadKodError(String(err), 0);
+    }
+  }
+  // ── Health ──────────────────────────────────────────────────
+  async health() {
+    return this.request("/health");
+  }
+  // ── Models ──────────────────────────────────────────────────
+  async models() {
+    const data = await this.request("/v1/models");
+    return data.data;
+  }
+  // ── Chat (non-streaming) ──────────────────────────────────
+  async chat(options) {
+    return this.request("/v1/chat/completions", {
+      method: "POST",
+      body: JSON.stringify({
+        model: options.model || this.defaultModel,
+        messages: options.messages,
+        stream: false,
+        tools: options.tools,
+        tool_choice: options.tool_choice,
+        max_tokens: options.max_tokens,
+        temperature: options.temperature,
+        top_p: options.top_p,
+        seed: options.seed
+      })
+    });
+  }
+  // ── Chat (streaming) ─────────────────────────────────────
+  async chatStream(options, callbacks = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    const resp = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: this.headers(),
+      signal: controller.signal,
+      body: JSON.stringify({
+        model: options.model || this.defaultModel,
+        messages: options.messages,
+        stream: true,
+        tools: options.tools,
+        tool_choice: options.tool_choice,
+        max_tokens: options.max_tokens,
+        temperature: options.temperature,
+        top_p: options.top_p,
+        seed: options.seed
+      })
+    });
+    clearTimeout(timer);
+    if (!resp.ok) {
+      let body;
+      try {
+        body = await resp.json();
+      } catch {
+        body = await resp.text();
+      }
+      const err = new RadKodError(`API error ${resp.status}`, resp.status, body);
+      callbacks.onError?.(err);
+      throw err;
+    }
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let fullText = "";
+    const toolCalls = /* @__PURE__ */ new Map();
+    let buffer = "";
+    try {
+      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) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") continue;
+          try {
+            const chunk = JSON.parse(data);
+            const delta = chunk.choices?.[0]?.delta;
+            if (delta?.content) {
+              fullText += delta.content;
+              callbacks.onToken?.(delta.content);
+            }
+            if (delta?.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                let existing = toolCalls.get(tc.index);
+                if (!existing) {
+                  existing = {
+                    id: tc.id || "",
+                    type: "function",
+                    function: { name: "", arguments: "" }
+                  };
+                  toolCalls.set(tc.index, existing);
+                }
+                if (tc.id) existing.id = tc.id;
+                if (tc.function?.name) existing.function.name += tc.function.name;
+                if (tc.function?.arguments) existing.function.arguments += tc.function.arguments;
+              }
+            }
+            if (chunk.choices?.[0]?.finish_reason === "tool_calls") {
+              for (const tc of toolCalls.values()) {
+                callbacks.onToolCall?.(tc);
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    } catch (err) {
+      callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+      throw err;
+    }
+    const result = {
+      text: fullText,
+      toolCalls: [...toolCalls.values()]
+    };
+    callbacks.onDone?.(fullText);
+    return result;
+  }
+  // ── Convenience: simple prompt ───────────────────────────
+  async prompt(text, model) {
+    const resp = await this.chat({
+      model,
+      messages: [{ role: "user", content: text }]
+    });
+    return resp.choices[0]?.message?.content || "";
+  }
+  // ── Convenience: streaming prompt ────────────────────────
+  async promptStream(text, onToken, model) {
+    const result = await this.chatStream(
+      { model, messages: [{ role: "user", content: text }] },
+      { onToken }
+    );
+    return result.text;
+  }
+  // ── Tool calling helper ──────────────────────────────────
+  async chatWithTools(options, toolHandlers, maxRounds = 5) {
+    const messages = [...options.messages];
+    let round = 0;
+    while (round < maxRounds) {
+      const resp = await this.chat({ ...options, messages });
+      const choice = resp.choices[0];
+      messages.push(choice.message);
+      if (!choice.message.tool_calls || choice.finish_reason !== "tool_calls") {
+        return { messages, finalText: choice.message.content || "" };
+      }
+      for (const tc of choice.message.tool_calls) {
+        const handler = toolHandlers[tc.function.name];
+        if (!handler) {
+          messages.push({
+            role: "tool",
+            tool_call_id: tc.id,
+            content: JSON.stringify({ error: `Unknown tool: ${tc.function.name}` })
+          });
+          continue;
+        }
+        try {
+          const args = JSON.parse(tc.function.arguments);
+          const result = await handler(args);
+          messages.push({
+            role: "tool",
+            tool_call_id: tc.id,
+            content: typeof result === "string" ? result : JSON.stringify(result)
+          });
+        } catch (err) {
+          messages.push({
+            role: "tool",
+            tool_call_id: tc.id,
+            content: JSON.stringify({ error: String(err) })
+          });
+        }
+      }
+      round++;
+    }
+    return { messages, finalText: messages[messages.length - 1]?.content || "" };
+  }
+};
+var index_default = RadKodAI;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RadKodAI,
+  RadKodError
+});

package/dist/index.mjs

@@ -0,0 +1,233 @@
+// src/index.ts
+var RadKodError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.name = "RadKodError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var RadKodAI = class {
+  constructor(config = {}) {
+    this.baseUrl = (config.baseUrl || "https://ai.radkod.com").replace(/\/$/, "");
+    this.apiKey = config.apiKey || "";
+    this.defaultModel = config.defaultModel || "z-ai/glm4.7";
+    this.timeout = config.timeout || 3e5;
+  }
+  // ── Headers ─────────────────────────────────────────────────
+  headers() {
+    const h = { "Content-Type": "application/json" };
+    if (this.apiKey) h["Authorization"] = `Bearer ${this.apiKey}`;
+    return h;
+  }
+  async request(path, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const resp = await fetch(`${this.baseUrl}${path}`, {
+        ...init,
+        headers: { ...this.headers(), ...init?.headers },
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!resp.ok) {
+        let body;
+        try {
+          body = await resp.json();
+        } catch {
+          body = await resp.text();
+        }
+        throw new RadKodError(
+          `API error ${resp.status}: ${typeof body === "string" ? body : JSON.stringify(body)}`,
+          resp.status,
+          body
+        );
+      }
+      return await resp.json();
+    } catch (err) {
+      clearTimeout(timer);
+      if (err instanceof RadKodError) throw err;
+      throw new RadKodError(String(err), 0);
+    }
+  }
+  // ── Health ──────────────────────────────────────────────────
+  async health() {
+    return this.request("/health");
+  }
+  // ── Models ──────────────────────────────────────────────────
+  async models() {
+    const data = await this.request("/v1/models");
+    return data.data;
+  }
+  // ── Chat (non-streaming) ──────────────────────────────────
+  async chat(options) {
+    return this.request("/v1/chat/completions", {
+      method: "POST",
+      body: JSON.stringify({
+        model: options.model || this.defaultModel,
+        messages: options.messages,
+        stream: false,
+        tools: options.tools,
+        tool_choice: options.tool_choice,
+        max_tokens: options.max_tokens,
+        temperature: options.temperature,
+        top_p: options.top_p,
+        seed: options.seed
+      })
+    });
+  }
+  // ── Chat (streaming) ─────────────────────────────────────
+  async chatStream(options, callbacks = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    const resp = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: this.headers(),
+      signal: controller.signal,
+      body: JSON.stringify({
+        model: options.model || this.defaultModel,
+        messages: options.messages,
+        stream: true,
+        tools: options.tools,
+        tool_choice: options.tool_choice,
+        max_tokens: options.max_tokens,
+        temperature: options.temperature,
+        top_p: options.top_p,
+        seed: options.seed
+      })
+    });
+    clearTimeout(timer);
+    if (!resp.ok) {
+      let body;
+      try {
+        body = await resp.json();
+      } catch {
+        body = await resp.text();
+      }
+      const err = new RadKodError(`API error ${resp.status}`, resp.status, body);
+      callbacks.onError?.(err);
+      throw err;
+    }
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let fullText = "";
+    const toolCalls = /* @__PURE__ */ new Map();
+    let buffer = "";
+    try {
+      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) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") continue;
+          try {
+            const chunk = JSON.parse(data);
+            const delta = chunk.choices?.[0]?.delta;
+            if (delta?.content) {
+              fullText += delta.content;
+              callbacks.onToken?.(delta.content);
+            }
+            if (delta?.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                let existing = toolCalls.get(tc.index);
+                if (!existing) {
+                  existing = {
+                    id: tc.id || "",
+                    type: "function",
+                    function: { name: "", arguments: "" }
+                  };
+                  toolCalls.set(tc.index, existing);
+                }
+                if (tc.id) existing.id = tc.id;
+                if (tc.function?.name) existing.function.name += tc.function.name;
+                if (tc.function?.arguments) existing.function.arguments += tc.function.arguments;
+              }
+            }
+            if (chunk.choices?.[0]?.finish_reason === "tool_calls") {
+              for (const tc of toolCalls.values()) {
+                callbacks.onToolCall?.(tc);
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    } catch (err) {
+      callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+      throw err;
+    }
+    const result = {
+      text: fullText,
+      toolCalls: [...toolCalls.values()]
+    };
+    callbacks.onDone?.(fullText);
+    return result;
+  }
+  // ── Convenience: simple prompt ───────────────────────────
+  async prompt(text, model) {
+    const resp = await this.chat({
+      model,
+      messages: [{ role: "user", content: text }]
+    });
+    return resp.choices[0]?.message?.content || "";
+  }
+  // ── Convenience: streaming prompt ────────────────────────
+  async promptStream(text, onToken, model) {
+    const result = await this.chatStream(
+      { model, messages: [{ role: "user", content: text }] },
+      { onToken }
+    );
+    return result.text;
+  }
+  // ── Tool calling helper ──────────────────────────────────
+  async chatWithTools(options, toolHandlers, maxRounds = 5) {
+    const messages = [...options.messages];
+    let round = 0;
+    while (round < maxRounds) {
+      const resp = await this.chat({ ...options, messages });
+      const choice = resp.choices[0];
+      messages.push(choice.message);
+      if (!choice.message.tool_calls || choice.finish_reason !== "tool_calls") {
+        return { messages, finalText: choice.message.content || "" };
+      }
+      for (const tc of choice.message.tool_calls) {
+        const handler = toolHandlers[tc.function.name];
+        if (!handler) {
+          messages.push({
+            role: "tool",
+            tool_call_id: tc.id,
+            content: JSON.stringify({ error: `Unknown tool: ${tc.function.name}` })
+          });
+          continue;
+        }
+        try {
+          const args = JSON.parse(tc.function.arguments);
+          const result = await handler(args);
+          messages.push({
+            role: "tool",
+            tool_call_id: tc.id,
+            content: typeof result === "string" ? result : JSON.stringify(result)
+          });
+        } catch (err) {
+          messages.push({
+            role: "tool",
+            tool_call_id: tc.id,
+            content: JSON.stringify({ error: String(err) })
+          });
+        }
+      }
+      round++;
+    }
+    return { messages, finalText: messages[messages.length - 1]?.content || "" };
+  }
+};
+var index_default = RadKodAI;
+export {
+  RadKodAI,
+  RadKodError,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@radkod/ai",
+  "version": "0.1.0",
+  "description": "Lightweight SDK for RadKod AI API — OpenAI-compatible LLM proxy with streaming and tool calling",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.0"
+  },
+  "keywords": ["ai", "llm", "openai", "sdk", "radkod", "streaming", "tool-calling"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/apo-bozdag/benvidia"
+  }
+}