tekimax-ts 0.1.6 → 1.0.0-beta.1

package/dist/index.cjs

@@ -0,0 +1,740 @@
+"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, {
+  ApiTypes: () => types_exports,
+  TekimaxClient: () => TekimaxClient,
+  TekimaxProvider: () => TekimaxProvider,
+  generateText: () => generateText,
+  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 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 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 response = await this.client.sendMessage(this.getLastUserMessage(options.messages), {
+      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 stream = this.client.sendMessageStream(this.getLastUserMessage(options.messages), {
+      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
+        };
+      }
+    }
+  }
+  getLastUserMessage(messages) {
+    const lastUser = messages.slice().reverse().find((m) => m.role === "user");
+    return lastUser?.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: message.content || "",
+        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"]
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiTypes,
+  TekimaxClient,
+  TekimaxProvider,
+  generateText,
+  tool
+});