tekimax-ts 0.1.7 → 0.1.8

package/dist/index.cjs

@@ -0,0 +1,1574 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AnthropicProvider: () => AnthropicProvider,
+  ApiTypes: () => types_exports,
+  GeminiProvider: () => GeminiProvider,
+  GrokProvider: () => GrokProvider,
+  OllamaProvider: () => OllamaProvider,
+  OpenAIProvider: () => OpenAIProvider,
+  OpenRouterProvider: () => OpenRouterProvider,
+  Tekimax: () => Tekimax,
+  TekimaxClient: () => TekimaxClient,
+  TekimaxProvider: () => TekimaxProvider,
+  fileToBase64: () => fileToBase64,
+  generateText: () => generateText,
+  parseThinking: () => parseThinking,
+  tool: () => tool
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/providers/tekimax/client.ts
+var import_eventsource_parser = require("eventsource-parser");
+var TekimaxResponse = class {
+  constructor(_raw) {
+    this._raw = _raw;
+  }
+  /**
+   * Access the raw response object returned by the API.
+   */
+  get raw() {
+    return this._raw;
+  }
+  /**
+   * Automatically extracts the text content from the response.
+   * It looks for the first "output_text" item in the response content.
+   */
+  get text() {
+    for (const item of this._raw.output) {
+      if (item.type === "message") {
+        for (const contentPart of item.content) {
+          if (contentPart.type === "output_text" || contentPart.type === "text") {
+            return contentPart.text;
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * The ID of the response.
+   */
+  get id() {
+    return this._raw.id;
+  }
+  /**
+   * The model used to generate the response.
+   */
+  get model() {
+    return this._raw.model;
+  }
+};
+var TekimaxClient = class {
+  /**
+   * Creates a new TekimaxClient.
+   *
+   * @param options - Configuration options for the client.
+   * @param options.baseUrl - The base URL of the API (default: "https://api.tekimax.com").
+   * @param options.apiKey - Your Tekimax API key.
+   *
+   * @example
+   * const client = new TekimaxClient({ apiKey: "tm_..." });
+   */
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl || "https://api.tekimax.com";
+    this.headers = {
+      "Content-Type": "application/json",
+      ...options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {}
+    };
+  }
+  async request(path, body, options) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body),
+      signal: options?.signal
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Tekimax API Error: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return new TekimaxResponse(data);
+  }
+  async *requestStream(path, body, options) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body),
+      signal: options?.signal
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Tekimax API Error: ${response.status} ${response.statusText}`
+      );
+    }
+    if (!response.body) {
+      throw new Error("No response body received for streaming request");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const buffer = [];
+    const parser = (0, import_eventsource_parser.createParser)({
+      onEvent(event) {
+        if (event.type === "event") {
+          try {
+            if (event.data === "[DONE]") return;
+            buffer.push(JSON.parse(event.data));
+          } catch (e) {
+          }
+        }
+      }
+    });
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        parser.feed(decoder.decode(value, { stream: true }));
+        while (buffer.length > 0) {
+          yield buffer.shift();
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Creates a new session and sends the initial message.
+   *
+   * @param message - The initial message text or array of message items to start the session.
+   * @param options - Additional configuration options (model, temperature, etc.).
+   *
+   * @example
+   * const response = await client.createSession("Hello, world!", { model: "gpt-4" });
+   * console.log(response.text);
+   */
+  async createSession(message, options) {
+    const body = {
+      ...options,
+      input: message
+    };
+    const { signal } = options || {};
+    const cleanBody = { ...body };
+    delete cleanBody.signal;
+    return this.request("/responses", cleanBody, { signal });
+  }
+  /**
+   * Sends a message to an existing session or starts a new one if no previous_response_id is provided.
+   *
+   * @param message - The message text or history array to send.
+   * @param options - Additional configuration options.
+   *
+   * @example
+   * const response = await client.sendMessage("What is the weather?", {
+   *   previous_response_id: "resp_123"
+   * });
+   * console.log(response.text);
+   */
+  async sendMessage(message, options) {
+    const body = {
+      ...options,
+      input: message,
+      stream: false
+    };
+    const { signal } = options || {};
+    const cleanBody = { ...body };
+    delete cleanBody.signal;
+    return this.request("/responses", cleanBody, { signal });
+  }
+  /**
+   * Sends a message and returns an asynchronous iterable of streaming events.
+   */
+  async *sendMessageStream(message, options) {
+    const body = {
+      ...options,
+      input: message,
+      stream: true
+    };
+    const { signal } = options || {};
+    const cleanBody = { ...body };
+    delete cleanBody.signal;
+    yield* this.requestStream("/responses", cleanBody, { signal });
+  }
+};
+
+// src/providers/tekimax/index.ts
+var TekimaxProvider = class {
+  constructor(options = {}) {
+    this.name = "tekimax";
+    this.client = new TekimaxClient(options);
+  }
+  async chat(options) {
+    const tools = options.tools?.map((t) => ({
+      type: "function",
+      name: t.function.name,
+      description: t.function.description ?? void 0,
+      parameters: t.function.parameters ?? void 0
+    }));
+    const input = this.mapMessages(options.messages);
+    const response = await this.client.sendMessage(input, {
+      model: options.model,
+      temperature: options.temperature,
+      max_output_tokens: options.maxTokens,
+      tools,
+      signal: options.signal
+    });
+    if (response.raw.output) {
+      const toolCalls = [];
+      for (const item of response.raw.output) {
+        if (item.type === "function_call") {
+          toolCalls.push({
+            id: item.call_id,
+            type: "function",
+            function: {
+              name: item.name,
+              arguments: item.arguments
+              // Already a string in generated types
+            }
+          });
+        }
+      }
+      if (toolCalls.length > 0) {
+        return {
+          message: {
+            role: "assistant",
+            content: response.text || null,
+            toolCalls
+          }
+        };
+      }
+    }
+    if (!response.text) {
+      if (options.tools && options.tools.length > 0) {
+        return { message: { role: "assistant", content: null } };
+      }
+      throw new Error("No text content in response");
+    }
+    return {
+      message: {
+        role: "assistant",
+        content: response.text
+      }
+    };
+  }
+  async *chatStream(options) {
+    const tools = options.tools?.map((t) => ({
+      type: "function",
+      name: t.function.name,
+      description: t.function.description ?? void 0,
+      parameters: t.function.parameters ?? void 0
+    }));
+    const input = this.mapMessages(options.messages);
+    const stream = this.client.sendMessageStream(input, {
+      model: options.model,
+      temperature: options.temperature,
+      max_output_tokens: options.maxTokens,
+      tools,
+      signal: options.signal
+    });
+    for await (const event of stream) {
+      if (event.type === "response.output_text.delta" && event.delta) {
+        yield {
+          delta: event.delta
+        };
+      }
+    }
+  }
+  // Returning any[] because generated ItemParam union is missing UserMessageItemParam
+  mapMessages(messages) {
+    const items = [];
+    for (const msg of messages) {
+      if (msg.role === "user") {
+        items.push({
+          type: "message",
+          role: "user",
+          content: msg.content || ""
+        });
+      } else if (msg.role === "assistant") {
+        if (msg.content) {
+          items.push({
+            type: "message",
+            role: "assistant",
+            content: [{ type: "output_text", text: msg.content }]
+          });
+        }
+      }
+    }
+    return items;
+  }
+};
+
+// src/providers/anthropic/index.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
+var AnthropicProvider = class {
+  constructor(options) {
+    this.name = "anthropic";
+    this.client = new import_sdk.default({ apiKey: options.apiKey });
+  }
+  async chat(options) {
+    const response = await this.client.messages.create({
+      model: options.model || "claude-3-5-sonnet-20240620",
+      max_tokens: options.maxTokens || 1024,
+      messages: this.mapMessages(options.messages),
+      tools: options.tools?.map(this.mapTool)
+    });
+    const textBlocks = response.content.filter((c) => c.type === "text");
+    const toolUseBlocks = response.content.filter((c) => c.type === "tool_use");
+    const text = textBlocks.map((b) => b.text).join("");
+    let toolCalls = void 0;
+    if (toolUseBlocks.length > 0) {
+      toolCalls = toolUseBlocks.map((b) => ({
+        id: b.id,
+        type: "function",
+        function: {
+          name: b.name,
+          arguments: JSON.stringify(b.input)
+        }
+      }));
+    }
+    return {
+      usage: {
+        promptTokens: response.usage.input_tokens,
+        completionTokens: response.usage.output_tokens,
+        totalTokens: response.usage.input_tokens + response.usage.output_tokens
+      },
+      message: {
+        role: "assistant",
+        content: text,
+        toolCalls
+      }
+    };
+  }
+  async *chatStream(options) {
+    const stream = await this.client.messages.create({
+      model: options.model || "claude-3-5-sonnet-20240620",
+      max_tokens: options.maxTokens || 1024,
+      messages: this.mapMessages(options.messages),
+      stream: true
+    });
+    for await (const chunk of stream) {
+      if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+        yield {
+          delta: chunk.delta.text
+        };
+      }
+    }
+  }
+  mapMessages(messages) {
+    return messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => {
+      let content = "";
+      if (typeof m.content === "string") {
+        content = m.content || "";
+      } else if (Array.isArray(m.content)) {
+        content = m.content.map((part) => {
+          if (part.type === "text") {
+            return { type: "text", text: part.text };
+          }
+          if (part.type === "image_url") {
+            const match = part.image_url.url.match(/^data:([^;]+);base64,(.+)$/);
+            if (match) {
+              const mimeType = match[1];
+              return {
+                type: "image",
+                source: {
+                  type: "base64",
+                  media_type: mimeType,
+                  data: match[2] || ""
+                }
+              };
+            }
+          }
+          return { type: "text", text: "" };
+        }).filter((part) => part.text !== "");
+      }
+      return {
+        role: m.role,
+        content
+      };
+    });
+  }
+  mapTool(tool2) {
+    return {
+      name: tool2.function.name,
+      description: tool2.function.description,
+      input_schema: tool2.function.parameters
+    };
+  }
+};
+
+// src/providers/gemini/index.ts
+var import_generative_ai = require("@google/generative-ai");
+var GeminiProvider = class {
+  constructor(options) {
+    this.name = "gemini";
+    this.client = new import_generative_ai.GoogleGenerativeAI(options.apiKey);
+  }
+  convertContent(content) {
+    if (!content) return "";
+    if (typeof content === "string") return content;
+    return content.map((part) => {
+      if (part.type === "text") {
+        return { text: part.text };
+      }
+      if (part.type === "image_url") {
+        const match = part.image_url.url.match(/^data:([^;]+);base64,(.+)$/);
+        if (match) {
+          return {
+            inlineData: {
+              mimeType: match[1],
+              data: match[2] || ""
+            }
+          };
+        }
+        return { text: "[Image Url not supported directly, please use base64 data uri]" };
+      }
+      return { text: "" };
+    });
+  }
+  async chat(options) {
+    const model = this.client.getGenerativeModel({
+      model: options.model || "gemini-pro",
+      tools: options.tools ? [{ functionDeclarations: options.tools.map(this.mapTool) }] : void 0
+    });
+    const chat = model.startChat({
+      history: this.mapHistory(options.messages),
+      generationConfig: {
+        maxOutputTokens: options.maxTokens,
+        temperature: options.temperature
+      }
+    });
+    const lastMsg = options.messages[options.messages.length - 1];
+    if (!lastMsg) {
+      return { message: { role: "assistant", content: "" } };
+    }
+    const content = this.convertContent(lastMsg.content);
+    const result = await chat.sendMessage(content);
+    const response = result.response;
+    const text = response.text();
+    const functionCalls = response.functionCalls();
+    let toolCalls = void 0;
+    if (functionCalls && functionCalls.length > 0) {
+      toolCalls = functionCalls.map((fc) => ({
+        id: fc.name,
+        // Gemini doesn't always provide unique call IDs, usage depends on flow.
+        type: "function",
+        function: {
+          name: fc.name,
+          arguments: JSON.stringify(fc.args)
+        }
+      }));
+    }
+    return {
+      message: {
+        role: "assistant",
+        content: text,
+        toolCalls
+      }
+    };
+  }
+  async *chatStream(options) {
+    const model = this.client.getGenerativeModel({
+      model: options.model || "gemini-pro",
+      tools: options.tools ? [{ functionDeclarations: options.tools.map(this.mapTool) }] : void 0
+    });
+    const chat = model.startChat({
+      history: this.mapHistory(options.messages),
+      generationConfig: {
+        maxOutputTokens: options.maxTokens,
+        temperature: options.temperature
+      }
+    });
+    const lastMsg = options.messages[options.messages.length - 1];
+    if (!lastMsg) {
+      return;
+    }
+    const content = this.convertContent(lastMsg.content);
+    const result = await chat.sendMessageStream(content);
+    for await (const chunk of result.stream) {
+      const chunkText = chunk.text();
+      const functionCalls = chunk.functionCalls();
+      if (functionCalls && functionCalls.length > 0) {
+        for (const fc of functionCalls) {
+          yield {
+            delta: "",
+            toolCallDelta: {
+              index: 0,
+              // simplistic index
+              type: "function",
+              function: {
+                name: fc.name,
+                arguments: JSON.stringify(fc.args)
+              }
+            }
+          };
+        }
+      }
+      if (chunkText) {
+        yield {
+          delta: chunkText
+        };
+      }
+    }
+  }
+  mapHistory(messages) {
+    return messages.slice(0, -1).map((m) => {
+      const parts = [];
+      if (m.role === "assistant" && m.toolCalls) {
+        m.toolCalls.forEach((tc) => {
+          parts.push({
+            functionCall: {
+              name: tc.function.name,
+              args: JSON.parse(tc.function.arguments)
+            }
+          });
+        });
+      }
+      if (m.role === "tool") {
+        parts.push({
+          functionResponse: {
+            name: m.name || "unknown",
+            response: { content: m.content }
+          }
+        });
+      } else {
+        const contentParts = this.convertContent(m.content);
+        if (Array.isArray(contentParts)) {
+          parts.push(...contentParts);
+        } else if (contentParts) {
+          parts.push({ text: contentParts });
+        }
+      }
+      return {
+        role: m.role === "user" ? "user" : "model",
+        parts
+      };
+    });
+  }
+  mapTool(tool2) {
+    return {
+      name: tool2.function.name,
+      description: tool2.function.description,
+      parameters: tool2.function.parameters
+    };
+  }
+};
+
+// src/providers/ollama/index.ts
+var import_browser = require("ollama/browser");
+var OllamaProvider = class {
+  constructor(options) {
+    this.name = "ollama";
+    this.client = new import_browser.Ollama({
+      host: options?.host || "http://127.0.0.1:11434",
+      fetch: options?.apiKey ? (url, init) => {
+        const headers = new Headers(init?.headers);
+        headers.set("Authorization", `Bearer ${options.apiKey}`);
+        return fetch(url, {
+          ...init,
+          headers
+        });
+      } : void 0
+    });
+  }
+  async chat(options) {
+    const response = await this.client.chat({
+      model: options.model || "llama2",
+      messages: this.mapMessages(options.messages),
+      tools: options.tools?.map(this.mapTool),
+      stream: false,
+      // @ts-ignore - Ollama types might not be updated yet
+      think: options.think
+    });
+    let toolCalls = void 0;
+    if (response.message.tool_calls) {
+      toolCalls = response.message.tool_calls.map((tc) => ({
+        id: `call_${Math.random().toString(36).slice(2)}`,
+        type: "function",
+        function: {
+          name: tc.function.name,
+          arguments: JSON.stringify(tc.function.arguments)
+        }
+      }));
+    }
+    return {
+      message: {
+        role: "assistant",
+        content: response.message.content,
+        // @ts-ignore
+        thinking: response.message.thinking,
+        // Native thinking field
+        toolCalls
+      }
+    };
+  }
+  async *chatStream(options) {
+    const stream = await this.client.chat({
+      model: options.model || "llama2",
+      messages: this.mapMessages(options.messages),
+      tools: options.tools?.map(this.mapTool),
+      stream: true,
+      // @ts-ignore
+      think: options.think
+    });
+    for await (const part of stream) {
+      const chunk = {
+        delta: part.message.content
+      };
+      if (part.message.thinking) {
+        chunk.thinking = part.message.thinking;
+      }
+      if (part.message.tool_calls) {
+        for (let i = 0; i < part.message.tool_calls.length; i++) {
+          const tc = part.message.tool_calls[i];
+          chunk.toolCallDelta = {
+            index: i,
+            type: "function",
+            function: {
+              name: tc.function.name,
+              arguments: JSON.stringify(tc.function.arguments)
+            }
+          };
+          yield {
+            delta: "",
+            toolCallDelta: {
+              index: i,
+              type: "function",
+              function: {
+                name: tc.function.name,
+                arguments: JSON.stringify(tc.function.arguments)
+              }
+            }
+          };
+        }
+        if (!part.message.content && !part.message.thinking) continue;
+      }
+      yield chunk;
+    }
+  }
+  mapMessages(messages) {
+    return messages.map((m) => {
+      let content = "";
+      const images = [];
+      if (typeof m.content === "string") {
+        content = m.content || "";
+      } else if (Array.isArray(m.content)) {
+        for (const part of m.content) {
+          if (part.type === "text") {
+            content += part.text;
+          } else if (part.type === "image_url") {
+            const match = part.image_url.url.match(/^data:image\/[a-z]+;base64,(.+)$/);
+            if (match) {
+              images.push(match[1]);
+            }
+          }
+        }
+      }
+      if (m.role === "tool") {
+        return {
+          role: "tool",
+          content,
+          // Ollama needs tool_name or name? Docs say tool_name in one example
+          // but python sdk usage shows name matching.
+          // REST API docs say `tool_name` for role `tool`.
+          name: m.name
+          // tool_name: m.name // redundancy
+        };
+      }
+      return {
+        role: m.role,
+        content,
+        images: images.length > 0 ? images : void 0,
+        tool_calls: m.toolCalls ? m.toolCalls.map((tc) => ({
+          type: "function",
+          function: {
+            name: tc.function.name,
+            arguments: JSON.parse(tc.function.arguments)
+          }
+        })) : void 0
+      };
+    });
+  }
+  mapTool(tool2) {
+    return {
+      type: "function",
+      function: {
+        name: tool2.function.name,
+        description: tool2.function.description,
+        parameters: tool2.function.parameters
+      }
+    };
+  }
+};
+
+// src/providers/openai/index.ts
+var import_openai = __toESM(require("openai"), 1);
+var OpenAIProvider = class {
+  constructor(options) {
+    this.name = "openai";
+    this.client = new import_openai.default({
+      apiKey: options.apiKey,
+      dangerouslyAllowBrowser: options.dangerouslyAllowBrowser
+    });
+  }
+  async chat(options) {
+    const response = await this.client.chat.completions.create({
+      model: options.model,
+      messages: this.mapMessages(options.messages),
+      tools: options.tools?.map(this.mapTool),
+      temperature: options.temperature,
+      max_tokens: options.maxTokens
+    });
+    const choice = response.choices[0];
+    if (!choice) throw new Error("No choice returned from OpenAI");
+    return {
+      usage: response.usage ? {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens
+      } : void 0,
+      message: this.mapResponseMessage(choice.message)
+    };
+  }
+  async *chatStream(options) {
+    const stream = await this.client.chat.completions.create({
+      model: options.model,
+      messages: this.mapMessages(options.messages),
+      tools: options.tools?.map(this.mapTool),
+      temperature: options.temperature,
+      max_tokens: options.maxTokens,
+      stream: true
+    });
+    for await (const chunk of stream) {
+      const choice = chunk.choices[0];
+      if (!choice) continue;
+      const delta = choice.delta;
+      let toolCallDelta = void 0;
+      if (delta.tool_calls && delta.tool_calls.length > 0) {
+        const tc = delta.tool_calls[0];
+        if (tc) {
+          toolCallDelta = {
+            index: tc.index,
+            id: tc.id,
+            type: "function",
+            function: tc.function ? {
+              name: tc.function.name,
+              arguments: tc.function.arguments
+            } : void 0
+          };
+        }
+      }
+      yield {
+        delta: delta.content || "",
+        toolCallDelta,
+        usage: void 0
+        // OpenAI stream doesn't always perform usage
+      };
+    }
+  }
+  // --- Mappers ---
+  mapMessages(messages) {
+    return messages.map((m) => {
+      if (m.role === "tool") {
+        return {
+          role: "tool",
+          content: m.content || "",
+          tool_call_id: m.toolCallId || "unknown"
+        };
+      }
+      if (m.role === "user") {
+        if (Array.isArray(m.content)) {
+          return {
+            role: "user",
+            content: m.content.map((c) => {
+              if (c.type === "text") {
+                return { type: "text", text: c.text };
+              }
+              if (c.type === "image_url") {
+                return {
+                  type: "image_url",
+                  image_url: {
+                    url: c.image_url.url,
+                    detail: c.image_url.detail
+                  }
+                };
+              }
+              return void 0;
+            }).filter(Boolean)
+          };
+        }
+        return { role: "user", content: m.content || "" };
+      }
+      if (m.role === "system") {
+        return { role: "system", content: (typeof m.content === "string" ? m.content : "") || "" };
+      }
+      if (m.role === "assistant") {
+        const tool_calls = m.toolCalls?.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.function.name,
+            arguments: tc.function.arguments
+          }
+        }));
+        return {
+          role: "assistant",
+          content: m.content || null,
+          tool_calls
+        };
+      }
+      throw new Error(`Unknown role: ${m.role}`);
+    });
+  }
+  mapTool(tool2) {
+    return {
+      type: "function",
+      function: {
+        name: tool2.function.name,
+        description: tool2.function.description,
+        parameters: tool2.function.parameters
+      }
+    };
+  }
+  mapResponseMessage(msg) {
+    return {
+      role: msg.role,
+      content: msg.content || "",
+      toolCalls: msg.tool_calls?.map((tc) => {
+        if (tc.type === "function") {
+          return {
+            id: tc.id,
+            function: {
+              name: tc.function.name,
+              arguments: tc.function.arguments
+            },
+            type: "function"
+          };
+        }
+        return void 0;
+      }).filter(Boolean)
+    };
+  }
+};
+
+// src/providers/grok/index.ts
+var import_openai2 = __toESM(require("openai"), 1);
+var GrokProvider = class {
+  constructor(options) {
+    this.name = "grok";
+    this.client = new import_openai2.default({
+      apiKey: options.apiKey,
+      baseURL: "https://api.x.ai/v1"
+    });
+  }
+  async chat(options) {
+    const response = await this.client.chat.completions.create({
+      model: options.model || "grok-beta",
+      messages: options.messages,
+      // Simple cast for compat
+      temperature: options.temperature,
+      max_tokens: options.maxTokens
+    });
+    const choice = response.choices[0];
+    return {
+      message: {
+        role: "assistant",
+        content: choice?.message?.content || ""
+      }
+    };
+  }
+  async *chatStream(options) {
+    const stream = await this.client.chat.completions.create({
+      model: options.model || "grok-beta",
+      messages: options.messages,
+      stream: true
+    });
+    for await (const chunk of stream) {
+      yield {
+        delta: chunk.choices[0]?.delta?.content || ""
+      };
+    }
+  }
+};
+
+// src/providers/openrouter/index.ts
+var import_openai3 = __toESM(require("openai"), 1);
+var OpenRouterProvider = class {
+  constructor(options) {
+    this.name = "openrouter";
+    this.client = new import_openai3.default({
+      apiKey: options.apiKey,
+      baseURL: "https://openrouter.ai/api/v1",
+      defaultHeaders: {
+        "HTTP-Referer": "https://tekimax.com",
+        // Required by OpenRouter
+        "X-Title": "Tekimax SDK"
+      }
+    });
+  }
+  async chat(options) {
+    const response = await this.client.chat.completions.create({
+      model: options.model,
+      messages: options.messages,
+      temperature: options.temperature,
+      max_tokens: options.maxTokens
+    });
+    const choice = response.choices[0];
+    return {
+      message: {
+        role: "assistant",
+        content: choice?.message?.content || ""
+      }
+    };
+  }
+  async *chatStream(options) {
+    const stream = await this.client.chat.completions.create({
+      model: options.model,
+      messages: options.messages,
+      stream: true
+    });
+    for await (const chunk of stream) {
+      yield {
+        delta: chunk.choices[0]?.delta?.content || ""
+      };
+    }
+  }
+};
+
+// src/gen/types.ts
+var types_exports = {};
+__export(types_exports, {
+  allowedToolChoiceTypeEnum: () => allowedToolChoiceTypeEnum,
+  allowedToolsParamTypeEnum: () => allowedToolsParamTypeEnum,
+  assistantMessageItemParamRoleEnum: () => assistantMessageItemParamRoleEnum,
+  assistantMessageItemParamTypeEnum: () => assistantMessageItemParamTypeEnum,
+  detailEnumEnum: () => detailEnumEnum,
+  developerMessageItemParamRoleEnum: () => developerMessageItemParamRoleEnum,
+  developerMessageItemParamTypeEnum: () => developerMessageItemParamTypeEnum,
+  errorStreamingEventTypeEnum: () => errorStreamingEventTypeEnum,
+  functionCallItemParamTypeEnum: () => functionCallItemParamTypeEnum,
+  functionCallItemStatusEnum: () => functionCallItemStatusEnum,
+  functionCallOutputItemParamTypeEnum: () => functionCallOutputItemParamTypeEnum,
+  functionCallOutputStatusEnumEnum: () => functionCallOutputStatusEnumEnum,
+  functionCallOutputTypeEnum: () => functionCallOutputTypeEnum,
+  functionCallStatusEnum: () => functionCallStatusEnum,
+  functionCallTypeEnum: () => functionCallTypeEnum,
+  functionToolChoiceTypeEnum: () => functionToolChoiceTypeEnum,
+  functionToolParamTypeEnum: () => functionToolParamTypeEnum,
+  functionToolTypeEnum: () => functionToolTypeEnum,
+  imageDetailEnum: () => imageDetailEnum,
+  includeEnumEnum: () => includeEnumEnum,
+  inputFileContentParamTypeEnum: () => inputFileContentParamTypeEnum,
+  inputFileContentTypeEnum: () => inputFileContentTypeEnum,
+  inputImageContentParamAutoParamTypeEnum: () => inputImageContentParamAutoParamTypeEnum,
+  inputImageContentTypeEnum: () => inputImageContentTypeEnum,
+  inputTextContentParamTypeEnum: () => inputTextContentParamTypeEnum,
+  inputTextContentTypeEnum: () => inputTextContentTypeEnum,
+  inputVideoContentTypeEnum: () => inputVideoContentTypeEnum,
+  itemReferenceParamTypeEnum: () => itemReferenceParamTypeEnum,
+  jsonObjectResponseFormatTypeEnum: () => jsonObjectResponseFormatTypeEnum,
+  jsonSchemaResponseFormatParamTypeEnum: () => jsonSchemaResponseFormatParamTypeEnum,
+  jsonSchemaResponseFormatTypeEnum: () => jsonSchemaResponseFormatTypeEnum,
+  messageRoleEnum: () => messageRoleEnum,
+  messageStatusEnum: () => messageStatusEnum,
+  messageTypeEnum: () => messageTypeEnum,
+  outputTextContentParamTypeEnum: () => outputTextContentParamTypeEnum,
+  outputTextContentTypeEnum: () => outputTextContentTypeEnum,
+  reasoningBodyTypeEnum: () => reasoningBodyTypeEnum,
+  reasoningEffortEnumEnum: () => reasoningEffortEnumEnum,
+  reasoningItemParamTypeEnum: () => reasoningItemParamTypeEnum,
+  reasoningSummaryContentParamTypeEnum: () => reasoningSummaryContentParamTypeEnum,
+  reasoningSummaryEnumEnum: () => reasoningSummaryEnumEnum,
+  reasoningTextContentTypeEnum: () => reasoningTextContentTypeEnum,
+  refusalContentParamTypeEnum: () => refusalContentParamTypeEnum,
+  refusalContentTypeEnum: () => refusalContentTypeEnum,
+  responseCompletedStreamingEventTypeEnum: () => responseCompletedStreamingEventTypeEnum,
+  responseContentPartAddedStreamingEventTypeEnum: () => responseContentPartAddedStreamingEventTypeEnum,
+  responseContentPartDoneStreamingEventTypeEnum: () => responseContentPartDoneStreamingEventTypeEnum,
+  responseCreatedStreamingEventTypeEnum: () => responseCreatedStreamingEventTypeEnum,
+  responseFailedStreamingEventTypeEnum: () => responseFailedStreamingEventTypeEnum,
+  responseFunctionCallArgumentsDeltaStreamingEventTypeEnum: () => responseFunctionCallArgumentsDeltaStreamingEventTypeEnum,
+  responseFunctionCallArgumentsDoneStreamingEventTypeEnum: () => responseFunctionCallArgumentsDoneStreamingEventTypeEnum,
+  responseInProgressStreamingEventTypeEnum: () => responseInProgressStreamingEventTypeEnum,
+  responseIncompleteStreamingEventTypeEnum: () => responseIncompleteStreamingEventTypeEnum,
+  responseOutputItemAddedStreamingEventTypeEnum: () => responseOutputItemAddedStreamingEventTypeEnum,
+  responseOutputItemDoneStreamingEventTypeEnum: () => responseOutputItemDoneStreamingEventTypeEnum,
+  responseOutputTextAnnotationAddedStreamingEventTypeEnum: () => responseOutputTextAnnotationAddedStreamingEventTypeEnum,
+  responseOutputTextDeltaStreamingEventTypeEnum: () => responseOutputTextDeltaStreamingEventTypeEnum,
+  responseOutputTextDoneStreamingEventTypeEnum: () => responseOutputTextDoneStreamingEventTypeEnum,
+  responseQueuedStreamingEventTypeEnum: () => responseQueuedStreamingEventTypeEnum,
+  responseReasoningDeltaStreamingEventTypeEnum: () => responseReasoningDeltaStreamingEventTypeEnum,
+  responseReasoningDoneStreamingEventTypeEnum: () => responseReasoningDoneStreamingEventTypeEnum,
+  responseReasoningSummaryDeltaStreamingEventTypeEnum: () => responseReasoningSummaryDeltaStreamingEventTypeEnum,
+  responseReasoningSummaryDoneStreamingEventTypeEnum: () => responseReasoningSummaryDoneStreamingEventTypeEnum,
+  responseReasoningSummaryPartAddedStreamingEventTypeEnum: () => responseReasoningSummaryPartAddedStreamingEventTypeEnum,
+  responseReasoningSummaryPartDoneStreamingEventTypeEnum: () => responseReasoningSummaryPartDoneStreamingEventTypeEnum,
+  responseRefusalDeltaStreamingEventTypeEnum: () => responseRefusalDeltaStreamingEventTypeEnum,
+  responseRefusalDoneStreamingEventTypeEnum: () => responseRefusalDoneStreamingEventTypeEnum,
+  responseResourceObjectEnum: () => responseResourceObjectEnum,
+  serviceTierEnumEnum: () => serviceTierEnumEnum,
+  specificFunctionParamTypeEnum: () => specificFunctionParamTypeEnum,
+  summaryTextContentTypeEnum: () => summaryTextContentTypeEnum,
+  systemMessageItemParamRoleEnum: () => systemMessageItemParamRoleEnum,
+  systemMessageItemParamTypeEnum: () => systemMessageItemParamTypeEnum,
+  textContentTypeEnum: () => textContentTypeEnum,
+  textResponseFormatTypeEnum: () => textResponseFormatTypeEnum,
+  toolChoiceValueEnumEnum: () => toolChoiceValueEnumEnum,
+  truncationEnumEnum: () => truncationEnumEnum,
+  urlCitationBodyTypeEnum: () => urlCitationBodyTypeEnum,
+  urlCitationParamTypeEnum: () => urlCitationParamTypeEnum,
+  userMessageItemParamRoleEnum: () => userMessageItemParamRoleEnum,
+  userMessageItemParamTypeEnum: () => userMessageItemParamTypeEnum,
+  verbosityEnumEnum: () => verbosityEnumEnum
+});
+var itemReferenceParamTypeEnum = {
+  item_reference: "item_reference"
+};
+var reasoningSummaryContentParamTypeEnum = {
+  summary_text: "summary_text"
+};
+var reasoningItemParamTypeEnum = {
+  reasoning: "reasoning"
+};
+var inputTextContentParamTypeEnum = {
+  input_text: "input_text"
+};
+var detailEnumEnum = {
+  low: "low",
+  high: "high",
+  auto: "auto"
+};
+var imageDetailEnum = {
+  low: "low",
+  high: "high",
+  auto: "auto"
+};
+var inputImageContentParamAutoParamTypeEnum = {
+  input_image: "input_image"
+};
+var inputFileContentParamTypeEnum = {
+  input_file: "input_file"
+};
+var userMessageItemParamTypeEnum = {
+  message: "message"
+};
+var userMessageItemParamRoleEnum = {
+  user: "user"
+};
+var systemMessageItemParamTypeEnum = {
+  message: "message"
+};
+var systemMessageItemParamRoleEnum = {
+  system: "system"
+};
+var developerMessageItemParamTypeEnum = {
+  message: "message"
+};
+var developerMessageItemParamRoleEnum = {
+  developer: "developer"
+};
+var urlCitationParamTypeEnum = {
+  url_citation: "url_citation"
+};
+var outputTextContentParamTypeEnum = {
+  output_text: "output_text"
+};
+var refusalContentParamTypeEnum = {
+  refusal: "refusal"
+};
+var assistantMessageItemParamTypeEnum = {
+  message: "message"
+};
+var assistantMessageItemParamRoleEnum = {
+  assistant: "assistant"
+};
+var functionCallItemStatusEnum = {
+  in_progress: "in_progress",
+  completed: "completed",
+  incomplete: "incomplete"
+};
+var functionCallStatusEnum = {
+  in_progress: "in_progress",
+  completed: "completed",
+  incomplete: "incomplete"
+};
+var functionCallItemParamTypeEnum = {
+  function_call: "function_call"
+};
+var inputVideoContentTypeEnum = {
+  input_video: "input_video"
+};
+var functionCallOutputItemParamTypeEnum = {
+  function_call_output: "function_call_output"
+};
+var includeEnumEnum = {
+  "reasoning.encrypted_content": "reasoning.encrypted_content",
+  "message.output_text.logprobs": "message.output_text.logprobs"
+};
+var functionToolParamTypeEnum = {
+  function: "function"
+};
+var specificFunctionParamTypeEnum = {
+  function: "function"
+};
+var toolChoiceValueEnumEnum = {
+  none: "none",
+  auto: "auto",
+  required: "required"
+};
+var allowedToolsParamTypeEnum = {
+  allowed_tools: "allowed_tools"
+};
+var verbosityEnumEnum = {
+  low: "low",
+  medium: "medium",
+  high: "high"
+};
+var textResponseFormatTypeEnum = {
+  text: "text"
+};
+var jsonSchemaResponseFormatParamTypeEnum = {
+  json_schema: "json_schema"
+};
+var reasoningEffortEnumEnum = {
+  none: "none",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "xhigh"
+};
+var reasoningSummaryEnumEnum = {
+  concise: "concise",
+  detailed: "detailed",
+  auto: "auto"
+};
+var truncationEnumEnum = {
+  auto: "auto",
+  disabled: "disabled"
+};
+var serviceTierEnumEnum = {
+  auto: "auto",
+  default: "default",
+  flex: "flex",
+  priority: "priority"
+};
+var messageRoleEnum = {
+  user: "user",
+  assistant: "assistant",
+  system: "system",
+  developer: "developer"
+};
+var inputTextContentTypeEnum = {
+  input_text: "input_text"
+};
+var urlCitationBodyTypeEnum = {
+  url_citation: "url_citation"
+};
+var outputTextContentTypeEnum = {
+  output_text: "output_text"
+};
+var textContentTypeEnum = {
+  text: "text"
+};
+var summaryTextContentTypeEnum = {
+  summary_text: "summary_text"
+};
+var reasoningTextContentTypeEnum = {
+  reasoning_text: "reasoning_text"
+};
+var refusalContentTypeEnum = {
+  refusal: "refusal"
+};
+var inputImageContentTypeEnum = {
+  input_image: "input_image"
+};
+var inputFileContentTypeEnum = {
+  input_file: "input_file"
+};
+var messageStatusEnum = {
+  in_progress: "in_progress",
+  completed: "completed",
+  incomplete: "incomplete"
+};
+var messageTypeEnum = {
+  message: "message"
+};
+var functionCallTypeEnum = {
+  function_call: "function_call"
+};
+var functionCallOutputStatusEnumEnum = {
+  in_progress: "in_progress",
+  completed: "completed",
+  incomplete: "incomplete"
+};
+var functionCallOutputTypeEnum = {
+  function_call_output: "function_call_output"
+};
+var reasoningBodyTypeEnum = {
+  reasoning: "reasoning"
+};
+var functionToolTypeEnum = {
+  function: "function"
+};
+var functionToolChoiceTypeEnum = {
+  function: "function"
+};
+var allowedToolChoiceTypeEnum = {
+  allowed_tools: "allowed_tools"
+};
+var jsonObjectResponseFormatTypeEnum = {
+  json_object: "json_object"
+};
+var jsonSchemaResponseFormatTypeEnum = {
+  json_schema: "json_schema"
+};
+var responseResourceObjectEnum = {
+  response: "response"
+};
+var responseCreatedStreamingEventTypeEnum = {
+  "response.created": "response.created"
+};
+var responseQueuedStreamingEventTypeEnum = {
+  "response.queued": "response.queued"
+};
+var responseInProgressStreamingEventTypeEnum = {
+  "response.in_progress": "response.in_progress"
+};
+var responseCompletedStreamingEventTypeEnum = {
+  "response.completed": "response.completed"
+};
+var responseFailedStreamingEventTypeEnum = {
+  "response.failed": "response.failed"
+};
+var responseIncompleteStreamingEventTypeEnum = {
+  "response.incomplete": "response.incomplete"
+};
+var responseOutputItemAddedStreamingEventTypeEnum = {
+  "response.output_item.added": "response.output_item.added"
+};
+var responseOutputItemDoneStreamingEventTypeEnum = {
+  "response.output_item.done": "response.output_item.done"
+};
+var responseReasoningSummaryPartAddedStreamingEventTypeEnum = {
+  "response.reasoning_summary_part.added": "response.reasoning_summary_part.added"
+};
+var responseReasoningSummaryPartDoneStreamingEventTypeEnum = {
+  "response.reasoning_summary_part.done": "response.reasoning_summary_part.done"
+};
+var responseContentPartAddedStreamingEventTypeEnum = {
+  "response.content_part.added": "response.content_part.added"
+};
+var responseContentPartDoneStreamingEventTypeEnum = {
+  "response.content_part.done": "response.content_part.done"
+};
+var responseOutputTextDeltaStreamingEventTypeEnum = {
+  "response.output_text.delta": "response.output_text.delta"
+};
+var responseOutputTextDoneStreamingEventTypeEnum = {
+  "response.output_text.done": "response.output_text.done"
+};
+var responseRefusalDeltaStreamingEventTypeEnum = {
+  "response.refusal.delta": "response.refusal.delta"
+};
+var responseRefusalDoneStreamingEventTypeEnum = {
+  "response.refusal.done": "response.refusal.done"
+};
+var responseReasoningDeltaStreamingEventTypeEnum = {
+  "response.reasoning.delta": "response.reasoning.delta"
+};
+var responseReasoningDoneStreamingEventTypeEnum = {
+  "response.reasoning.done": "response.reasoning.done"
+};
+var responseReasoningSummaryDeltaStreamingEventTypeEnum = {
+  "response.reasoning_summary_text.delta": "response.reasoning_summary_text.delta"
+};
+var responseReasoningSummaryDoneStreamingEventTypeEnum = {
+  "response.reasoning_summary_text.done": "response.reasoning_summary_text.done"
+};
+var responseOutputTextAnnotationAddedStreamingEventTypeEnum = {
+  "response.output_text.annotation.added": "response.output_text.annotation.added"
+};
+var responseFunctionCallArgumentsDeltaStreamingEventTypeEnum = {
+  "response.function_call_arguments.delta": "response.function_call_arguments.delta"
+};
+var responseFunctionCallArgumentsDoneStreamingEventTypeEnum = {
+  "response.function_call_arguments.done": "response.function_call_arguments.done"
+};
+var errorStreamingEventTypeEnum = {
+  error: "error"
+};
+
+// src/core/tool.ts
+function tool(def) {
+  return def;
+}
+
+// src/core/generate.ts
+async function generateText({
+  adapter,
+  ...options
+}) {
+  const { model, tools, maxSteps = 1, temperature, maxTokens, signal } = options;
+  const currentMessages = [...options.messages];
+  let steps = 0;
+  const toolDefinitions = tools ? Object.values(tools) : void 0;
+  while (steps < maxSteps) {
+    steps++;
+    const result = await adapter.chat({
+      model,
+      messages: currentMessages,
+      tools: toolDefinitions,
+      temperature,
+      maxTokens,
+      signal
+    });
+    const { message } = result;
+    currentMessages.push(message);
+    if (!message.toolCalls || message.toolCalls.length === 0) {
+      return {
+        text: typeof message.content === "string" ? message.content || "" : Array.isArray(message.content) ? message.content.filter((p) => p.type === "text").map((p) => p.text).join("") : "",
+        toolCalls: [],
+        toolResults: [],
+        finishReason: "stop",
+        usage: result.usage || { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+      };
+    }
+    const toolResults = await Promise.all(
+      message.toolCalls.map(async (call) => {
+        const tool2 = tools?.[call.function.name];
+        if (!tool2) {
+          return {
+            id: call.id,
+            result: `Error: Tool ${call.function.name} not found`
+          };
+        }
+        try {
+          const args = JSON.parse(call.function.arguments);
+          const output = await tool2.execute(args);
+          return {
+            id: call.id,
+            result: output
+          };
+        } catch (error) {
+          return {
+            id: call.id,
+            result: `Error executing tool: ${error.message}`
+          };
+        }
+      })
+    );
+    for (const res of toolResults) {
+      currentMessages.push({
+        role: "tool",
+        content: JSON.stringify(res.result),
+        toolCallId: res.id,
+        name: message.toolCalls.find((c) => c.id === res.id)?.function.name
+      });
+    }
+  }
+  return {
+    text: "",
+    toolCalls: [],
+    toolResults: [],
+    finishReason: "length",
+    // or 'tool_calls' if strictly ending on tools
+    usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+    warnings: ["Max steps reached"]
+  };
+}
+
+// src/core/utils.ts
+var fileToBase64 = (file) => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = (error) => reject(error);
+  });
+};
+var parseThinking = (content) => {
+  const thinkRegex = /<think>([\s\S]*?)<\/think>/;
+  const match = content.match(thinkRegex);
+  if (match) {
+    return {
+      think: match[1],
+      rest: content.replace(thinkRegex, "").trim()
+    };
+  }
+  if (content.startsWith("<think>")) {
+    return {
+      think: content.replace("<think>", ""),
+      rest: ""
+      // Still thinking
+    };
+  }
+  return { think: null, rest: content };
+};
+
+// src/namespaces/text.ts
+var TextNamespace = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /**
+   * Generate text from a prompt (Chat Completion).
+   */
+  async generate(options) {
+    return this.provider.chat(options);
+  }
+  /**
+   * Stream text generation.
+   */
+  async *generateStream(options) {
+    for await (const chunk of this.provider.chatStream(options)) {
+      yield chunk;
+    }
+  }
+  // Alias for 'chat' to match OpenAI conventions if needed
+  get chat() {
+    return {
+      completions: {
+        create: (options) => this.generate(options),
+        createStream: (options) => this.generateStream(options)
+      }
+    };
+  }
+};
+
+// src/namespaces/images.ts
+var ImagesNamespace = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /**
+   * Generate images from a prompt.
+   */
+  async generate(options) {
+    if (!this.provider.generateImage) {
+      throw new Error(`Provider '${this.provider.name}' does not support image generation`);
+    }
+    return this.provider.generateImage(options);
+  }
+  /**
+   * Edit an image with a prompt.
+   */
+  async edit(options) {
+    if (!this.provider.editImage) {
+      throw new Error(`Provider '${this.provider.name}' does not support image editing`);
+    }
+    return this.provider.editImage(options);
+  }
+  /**
+   * Analyze an image (Vision).
+   */
+  async analyze(options) {
+    if (!this.provider.analyzeImage) {
+      throw new Error(`Provider '${this.provider.name}' does not support image analysis`);
+    }
+    return this.provider.analyzeImage(options);
+  }
+};
+
+// src/namespaces/audio.ts
+var AudioNamespace = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /**
+   * Convert text to speech.
+   */
+  async speak(options) {
+    if (!this.provider.generateSpeech) {
+      throw new Error(`Provider '${this.provider.name}' does not support speech generation`);
+    }
+    return this.provider.generateSpeech(options);
+  }
+};
+
+// src/namespaces/videos.ts
+var VideosNamespace = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /**
+   * Generate a video from a prompt.
+   */
+  async generate(options) {
+    if (!this.provider.generateVideo) {
+      throw new Error(`Provider '${this.provider.name}' does not support video generation`);
+    }
+    return this.provider.generateVideo(options);
+  }
+  /**
+   * Analyze a video (Video-to-Text).
+   */
+  async analyze(options) {
+    if (!this.provider.analyzeVideo) {
+      throw new Error(`Provider '${this.provider.name}' does not support video analysis`);
+    }
+    return this.provider.analyzeVideo(options);
+  }
+};
+
+// src/tekimax.ts
+var Tekimax = class {
+  constructor(options) {
+    this.provider = options.provider;
+    this.text = new TextNamespace(this.provider);
+    this.images = new ImagesNamespace(this.provider);
+    this.audio = new AudioNamespace(this.provider);
+    this.videos = new VideosNamespace(this.provider);
+  }
+  /**
+   * @deprecated Use client.text.chat instead. Kept for backward compatibility.
+   */
+  get chat() {
+    return this.text.chat;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnthropicProvider,
+  ApiTypes,
+  GeminiProvider,
+  GrokProvider,
+  OllamaProvider,
+  OpenAIProvider,
+  OpenRouterProvider,
+  Tekimax,
+  TekimaxClient,
+  TekimaxProvider,
+  fileToBase64,
+  generateText,
+  parseThinking,
+  tool
+});