lemura 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-03-07
+
+### Added
+- Structured logging system with colors and severity levels (FATAL, ERROR, WARN, INFO, DEBUG).
+- Integrated logging into `SessionManager` and `OpenAICompatibleAdapter`.
+- Added `problem` and `hints` to `LemuraError` for better end-user feedback.
+- Dedicated `ILogger` interface and `DefaultLogger` implementation.
+- Short Term Memory (STM) system for persistent memory across session boundaries
+- Scratchpad tools for managing agent's internal reasoning state
+- `ShortTermMemoryRegistry` for memory item lifecycle management
+- `summarize_sandwich` tool for context compression using sandwich strategy
+
+### Changed
+- `SessionManager` — Core ReAct runtime integration entry point, now integrated with logging.
+- `OpenAICompatibleAdapter` — Reference adapter for OpenAI, now integrated with logging.
+
+### Added (Core)
+- `OpenAICompatibleAdapter` — Reference adapter for OpenAI and standard API-compatible providers.
+- `ContextManager` — Core context logic coordinating multiple string reduction behaviors.
+- `SandwichCompressionStrategy` — Strategy for preserving recency and foundation context.
+- `HistoryCompressionStrategy` — Strategy for compressing history via summarization.
+- `SessionManager` — Core ReAct runtime integration entry point.
+- `ToolRegistry` — Standardized tooling implementation.
+- `SkillInjector` — Advanced dynamic system prompting mechanism.
+- `ToolResponseProcessor` — Evaluates and handles heavy responses.
+- `ContinuationPlanner` — Multi-step sequential tool handling abstraction.
+- `InMemoryRAGAdapter` — Minimal in-memory document ingestion/query layer.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 rzafiamy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,143 @@
+  <img src="./docs/assets/logo.png" alt="lemura logo" width="200" />
+
+# lemura
+
+**A provider-agnostic, premium agentic AI runtime for the modern web.**
+
+[![npm version](https://img.shields.io/npm/v/lemura.svg?style=flat-square)](https://www.npmjs.com/package/lemura)
+[![license](https://img.shields.io/npm/l/lemura.svg?style=flat-square)](https://github.com/rzafiamy/lemura/blob/main/LICENSE)
+[![build](https://img.shields.io/github/actions/workflow/status/lemura-ai/lemura/ci.yml?branch=main&style=flat-square)](https://github.com/rzafiamy/lemura/actions)
+[![coverage](https://img.shields.io/codecov/c/github/lemura-ai/lemura?style=flat-square)](https://codecov.io/gh/lemura-ai/lemura)
+
+---
+
+`lemura` is a robust, provider-agnostic npm package designed to encapsulate a full agentic AI runtime. It simplifies the complex orchestration of LLMs, tools, and context management into a single, cohesive interface.
+
+## 🚀 Install
+
+```bash
+pnpm add lemura
+# or
+npm install lemura
+```
+
+## ⚙️ Environment Variables
+
+The built-in `OpenAICompatibleAdapter` can be configured using environment variables. To load them from a `.env` file in Node.js, you'll typically need a library like `dotenv`:
+
+```bash
+npm install dotenv
+```
+
+Then at the very top of your entry point:
+
+```ts
+import 'dotenv/config';
+```
+
+Create a `.env` file in your project root:
+
+```ini
+# Provider Configuration (OpenAI, Groq, Together, Ollama, etc.)
+LEMURA_API_KEY=your_api_key_here
+LEMURA_BASE_URL=https://api.openai.com/v1
+LEMURA_MODEL=gpt-4o-mini
+
+# Fallbacks (Lemura also checks standard OpenAI variables)
+OPENAI_API_KEY=your_api_key_here
+OPENAI_BASE_URL=https://api.openai.com/v1
+OPENAI_MODEL=gpt-4o-mini
+```
+
+## ⚡ Quick Start
+
+```ts
+import { SessionManager, OpenAICompatibleAdapter } from 'lemura';
+
+async function main() {
+  const adapter = new OpenAICompatibleAdapter({
+    baseUrl: 'https://api.openai.com/v1',
+    apiKey: process.env.OPENAI_API_KEY || '',
+    defaultModel: 'gpt-4o-mini'
+  });
+
+  const session = new SessionManager({
+    adapter,
+    model: 'gpt-4o-mini',
+    maxTokens: 100000,
+  });
+
+  const response = await session.run('What is lemura?');
+  console.log(response);
+}
+
+main();
+```
+
+## 🧠 Core Concepts
+
+Explore the architecture and advanced capabilities of `lemura`:
+
+- 🏁 [**Getting Started**](./docs/guides/getting-started.md) — Fundamental setup and concepts.
+- 🧹 [**Context Management**](./docs/guides/context-management.md) — Advanced compression strategies.
+- 🔌 [**Adapters**](./docs/guides/adapters.md) — Connecting to OpenAI, Groq, Anthropic, and more.
+- 🛠️ [**Tools and Skills**](./docs/guides/tools-and-skills.md) — Extending agent capabilities.
+- ⚡ [**Advanced Execution**](./docs/guides/advanced-execution.md) — Goal planning and continuation.
+
+## 📦 API Overview
+
+| Export | Description |
+|---|---|
+| `SessionManager` | The main entry point orchestrating the ReAct loop and tools. |
+| `ContextManager` | Manages the conversation history using compression strategies. |
+| `OpenAICompatibleAdapter` | Reference adapter for OpenAI, Groq, Together, etc. |
+| `ToolRegistry` | Registers and executes tools for the agent. |
+| `SkillInjector` | Loads and formats YAML/Markdown skills into system prompts. |
+| `DefaultLogger` | Colorized logger with Problem/Hints metadata support. |
+
+## 🪵 Logging and Tracing
+
+`lemura` features a premium, structured logging system designed for developer experience. It provides colorized output and actionable hints for errors.
+
+```ts
+import { SessionManager, DefaultLogger, LogLevel } from 'lemura';
+
+const logger = new DefaultLogger();
+logger.setLevel(LogLevel.DEBUG); // Set to show trace-level information
+
+const session = new SessionManager({
+  adapter,
+  model: 'gpt-4o-mini',
+  maxTokens: 100000,
+  logger: logger // Inject the logger
+});
+```
+
+When an error occurs (like an invalid API key), `lemura` provides beautiful, structured feedback:
+
+```text
+2026-03-07T13:05:49.686Z [FATAL] Provider call failed: HTTP 401: Unauthorized
+  PROBLEM: Authentication failed. The API key is invalid or missing.
+  HINTS:
+    - Ensure your API key is correctly configured in the adapter or environment variables.
+    - Check if the API key has expired or been revoked.
+```
+
+## 🔌 Provider Adapters
+
+`lemura` interacts with LLMs exclusively through the `IProviderAdapter` interface, ensuring zero lock-in.
+
+| Adapter | Status | Description |
+|---|---|---|
+| `OpenAICompatibleAdapter` | ✅ Built-in | Wrapper for OpenAI and API-compatible endpoints. |
+
+> [!TIP]
+> To write a custom adapter for another provider, see the [Custom Adapter Recipe](./docs/recipes/custom-adapter.md).
+
+## 🤝 Contributing
+
+We welcome contributions! Please read our [Internal Rules](./.cursor/rules/Project.md) and [Documentation Guidelines](./.cursor/rules/Documentation.md) before submitting a PR.
+
+## 📄 License
+
+Distributed under the **MIT License**. See `LICENSE` for more information.

package/dist/adapters/index.d.mts

@@ -0,0 +1,45 @@
+import { e as IProviderAdapter, c as CompletionRequest, d as CompletionResponse, b as CompletionChunk, M as ModelInfo, k as TranscriptionRequest, l as TranscriptionResponse, S as SynthesisRequest, A as AudioChunk, V as VisionRequest, m as VisionResponse, f as ImageGenRequest, g as ImageGenResponse } from '../adapters-BnG0LEYD.mjs';
+import '../storage-DMcliVVj.mjs';
+import '../rag-La_Bo-J8.mjs';
+import '../logger-DxvKliuk.mjs';
+
+interface RetryConfig {
+    maxRetries: number;
+    baseDelayMs: number;
+}
+interface OpenAICompatibleAdapterConfig {
+    baseUrl?: string;
+    apiKey?: string;
+    defaultModel?: string;
+    defaultHeaders?: Record<string, string>;
+    timeout?: number;
+    retry?: RetryConfig;
+}
+/**
+ * Reference implementation of an OpenAI-compatible provider adapter.
+ */
+declare class OpenAICompatibleAdapter implements IProviderAdapter {
+    readonly name = "openai_compatible";
+    readonly version = "1.0.0";
+    private baseUrl;
+    private apiKey;
+    private defaultModel;
+    private defaultHeaders;
+    private timeoutMs;
+    private retryConfig;
+    constructor(config?: OpenAICompatibleAdapterConfig);
+    private fetchWithRetry;
+    private mapFinishReason;
+    private buildPayload;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    stream(request: CompletionRequest): AsyncIterable<CompletionChunk>;
+    estimateTokens(text: string): number;
+    getModelInfo(): ModelInfo;
+    healthCheck(): Promise<boolean>;
+    transcribe(request: TranscriptionRequest): Promise<TranscriptionResponse>;
+    synthesize(request: SynthesisRequest): AsyncIterable<AudioChunk>;
+    describeImage(request: VisionRequest): Promise<VisionResponse>;
+    generateImage(request: ImageGenRequest): Promise<ImageGenResponse>;
+}
+
+export { OpenAICompatibleAdapter, type OpenAICompatibleAdapterConfig, type RetryConfig };

package/dist/adapters/index.d.ts

@@ -0,0 +1,45 @@
+import { e as IProviderAdapter, c as CompletionRequest, d as CompletionResponse, b as CompletionChunk, M as ModelInfo, k as TranscriptionRequest, l as TranscriptionResponse, S as SynthesisRequest, A as AudioChunk, V as VisionRequest, m as VisionResponse, f as ImageGenRequest, g as ImageGenResponse } from '../adapters-BSkhv5ac.js';
+import '../storage-BGu4Loao.js';
+import '../rag-La_Bo-J8.js';
+import '../logger-DxvKliuk.js';
+
+interface RetryConfig {
+    maxRetries: number;
+    baseDelayMs: number;
+}
+interface OpenAICompatibleAdapterConfig {
+    baseUrl?: string;
+    apiKey?: string;
+    defaultModel?: string;
+    defaultHeaders?: Record<string, string>;
+    timeout?: number;
+    retry?: RetryConfig;
+}
+/**
+ * Reference implementation of an OpenAI-compatible provider adapter.
+ */
+declare class OpenAICompatibleAdapter implements IProviderAdapter {
+    readonly name = "openai_compatible";
+    readonly version = "1.0.0";
+    private baseUrl;
+    private apiKey;
+    private defaultModel;
+    private defaultHeaders;
+    private timeoutMs;
+    private retryConfig;
+    constructor(config?: OpenAICompatibleAdapterConfig);
+    private fetchWithRetry;
+    private mapFinishReason;
+    private buildPayload;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    stream(request: CompletionRequest): AsyncIterable<CompletionChunk>;
+    estimateTokens(text: string): number;
+    getModelInfo(): ModelInfo;
+    healthCheck(): Promise<boolean>;
+    transcribe(request: TranscriptionRequest): Promise<TranscriptionResponse>;
+    synthesize(request: SynthesisRequest): AsyncIterable<AudioChunk>;
+    describeImage(request: VisionRequest): Promise<VisionResponse>;
+    generateImage(request: ImageGenRequest): Promise<ImageGenResponse>;
+}
+
+export { OpenAICompatibleAdapter, type OpenAICompatibleAdapterConfig, type RetryConfig };

package/dist/adapters/index.js

@@ -0,0 +1,371 @@
+'use strict';
+
+// src/types/errors.ts
+var LemuraError = class extends Error {
+  /**
+   * @param message - The error message
+   * @param code - The error code for programmatic handling
+   * @param problem - A clear description of the problem for the end user
+   * @param hints - A list of suggestions to resolve the issue
+   */
+  constructor(message, code, problem, hints = []) {
+    super(message);
+    this.code = code;
+    this.problem = problem;
+    this.hints = hints;
+    this.name = "LemuraError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var LemuraAdapterError = class extends LemuraError {
+  constructor(message, code = "ADAPTER_ERROR", cause, problem, hints = []) {
+    super(message, code, problem, hints);
+    this.cause = cause;
+    this.name = "LemuraAdapterError";
+  }
+};
+
+// src/adapters/OpenAICompatibleAdapter.ts
+var OpenAICompatibleAdapter = class {
+  name = "openai_compatible";
+  version = "1.0.0";
+  baseUrl;
+  apiKey;
+  defaultModel;
+  defaultHeaders;
+  timeoutMs;
+  retryConfig;
+  constructor(config = {}) {
+    this.baseUrl = (config.baseUrl ?? process.env.LEMURA_BASE_URL ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1").replace(/\/$/, "");
+    this.apiKey = config.apiKey ?? process.env.LEMURA_API_KEY ?? process.env.OPENAI_API_KEY ?? "";
+    this.defaultModel = config.defaultModel ?? process.env.LEMURA_MODEL ?? process.env.OPENAI_MODEL ?? "gpt-3.5-turbo";
+    this.defaultHeaders = config.defaultHeaders || {};
+    this.timeoutMs = config.timeout || 3e4;
+    this.retryConfig = config.retry || { maxRetries: 2, baseDelayMs: 1e3 };
+  }
+  async fetchWithRetry(url, init) {
+    let attempts = 0;
+    while (attempts <= this.retryConfig.maxRetries) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+        const headers = {
+          "Authorization": `Bearer ${this.apiKey}`,
+          ...this.defaultHeaders
+        };
+        if (init.headers) {
+          Object.assign(headers, init.headers);
+        }
+        if (headers["Content-Type"] === "unset") {
+          delete headers["Content-Type"];
+        } else if (!headers["Content-Type"]) {
+          headers["Content-Type"] = "application/json";
+        }
+        const response = await fetch(url, {
+          ...init,
+          signal: controller.signal,
+          headers
+        });
+        clearTimeout(timeoutId);
+        if (response.ok) return response;
+        if ((response.status === 429 || response.status === 503) && attempts < this.retryConfig.maxRetries) {
+          attempts++;
+          const delay = this.retryConfig.baseDelayMs * Math.pow(2, attempts - 1);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        const errorText = await response.text().catch(() => "");
+        let problem = "The server replied with an error during the API call.";
+        let hints = ["Check the API documentation for the provider you are using."];
+        if (response.status === 401) {
+          problem = "Authentication failed. The API key is invalid or missing.";
+          hints = [
+            "Ensure your API key is correctly configured in the adapter or environment variables.",
+            "Check if the API key has expired or been revoked."
+          ];
+        } else if (response.status === 404) {
+          problem = "The requested resource or model was not found.";
+          hints = [
+            "Verify that the baseUrl is correct (e.g., https://api.openai.com/v1).",
+            "Check if the model name is correct and available for your account.",
+            "Ensure you are not appending extra paths to the baseUrl."
+          ];
+        } else if (response.status === 429) {
+          problem = "Rate limit exceeded.";
+          hints = [
+            "Wait a few seconds before retrying.",
+            "Check your usage limits and billing status on the provider dashboard."
+          ];
+        }
+        throw new LemuraAdapterError(
+          `HTTP ${response.status}: ${errorText}`,
+          "HTTP_ERROR",
+          { status: response.status, body: errorText },
+          problem,
+          hints
+        );
+      } catch (err) {
+        if (err instanceof LemuraAdapterError) throw err;
+        if (attempts < this.retryConfig.maxRetries) {
+          attempts++;
+          const delay = this.retryConfig.baseDelayMs * Math.pow(2, attempts - 1);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        throw new LemuraAdapterError(
+          `Network request failed: ${err instanceof Error ? err.message : String(err)}`,
+          "NETWORK_ERROR",
+          err,
+          "A network error occurred while connecting to the provider.",
+          [
+            "Check your internet connection.",
+            "Verify that the baseUrl is reachable from your network.",
+            "Check for proxy or firewall settings that might block the request."
+          ]
+        );
+      }
+    }
+    throw new LemuraAdapterError(
+      "Max retries exceeded",
+      "MAX_RETRIES",
+      void 0,
+      "The request failed after multiple retry attempts.",
+      ["Check if the provider service is down or experiencing high load."]
+    );
+  }
+  mapFinishReason(reason) {
+    if (!reason) return "stop";
+    const r = reason.toLowerCase();
+    if (r === "tool_calls" || r === "tool_call") return "tool_call";
+    if (r === "length" || r === "max_tokens") return "max_tokens";
+    if (r === "content_filter" || r === "error") return "error";
+    return "stop";
+  }
+  buildPayload(request) {
+    const payload = {
+      model: request.model || this.defaultModel,
+      messages: request.messages
+    };
+    if (request.maxTokens !== void 0) payload.max_tokens = request.maxTokens;
+    if (request.temperature !== void 0) payload.temperature = request.temperature;
+    if (request.stopSequences?.length) payload.stop = request.stopSequences;
+    if (request.stream) payload.stream = true;
+    if (request.tools && request.tools.length > 0) {
+      payload.tools = request.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters
+        }
+      }));
+    }
+    return payload;
+  }
+  async complete(request) {
+    const payload = this.buildPayload(request);
+    const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    });
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    if (!choice) {
+      throw new LemuraAdapterError("Invalid response format: missing choices", "INVALID_RESPONSE", data);
+    }
+    const message = choice.message;
+    let toolCalls;
+    if (message.tool_calls && message.tool_calls.length > 0) {
+      toolCalls = message.tool_calls.map((tc) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: tc.function.arguments
+      }));
+    }
+    return {
+      content: message.content || "",
+      toolCalls,
+      finishReason: this.mapFinishReason(choice.finish_reason),
+      usage: {
+        promptTokens: data.usage?.prompt_tokens || 0,
+        completionTokens: data.usage?.completion_tokens || 0,
+        totalTokens: data.usage?.total_tokens || 0
+      },
+      rawResponse: data
+    };
+  }
+  async *stream(request) {
+    const payload = this.buildPayload({ ...request, stream: true });
+    const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    });
+    if (!response.body) {
+      throw new LemuraAdapterError("Response body is null", "STREAM_ERROR");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed === "data: [DONE]") continue;
+          if (trimmed.startsWith("data: ")) {
+            const jsonStr = trimmed.slice(6);
+            let data;
+            try {
+              data = JSON.parse(jsonStr);
+            } catch (err) {
+              continue;
+            }
+            const choice = data.choices?.[0];
+            if (!choice) continue;
+            const delta = choice.delta?.content || "";
+            const toolCallBlock = choice.delta?.tool_calls?.[0];
+            let toolCallDelta;
+            if (toolCallBlock) {
+              toolCallDelta = {
+                id: toolCallBlock.id,
+                name: toolCallBlock.function?.name,
+                arguments: toolCallBlock.function?.arguments
+              };
+            }
+            const isFinished = choice.finish_reason !== null && choice.finish_reason !== void 0;
+            yield {
+              delta,
+              finished: isFinished,
+              ...toolCallDelta && { toolCallDelta },
+              ...isFinished && { finishReason: this.mapFinishReason(choice.finish_reason) }
+            };
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+  getModelInfo() {
+    return {
+      supportsVision: true,
+      supportsTools: true,
+      contextWindow: 128e3
+    };
+  }
+  async healthCheck() {
+    try {
+      const resp = await this.fetchWithRetry(`${this.baseUrl}/models`, { method: "GET" });
+      return resp.ok;
+    } catch {
+      return false;
+    }
+  }
+  async transcribe(request) {
+    const binaryString = atob(request.audioBase64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    const blob = new Blob([bytes], { type: request.mimeType });
+    const formData = new FormData();
+    formData.append("file", blob, "audio.webm");
+    formData.append("model", "whisper-1");
+    if (request.language) formData.append("language", request.language);
+    const response = await this.fetchWithRetry(`${this.baseUrl}/audio/transcriptions`, {
+      method: "POST",
+      body: formData,
+      headers: {
+        "Content-Type": "unset"
+      }
+    });
+    const data = await response.json();
+    return {
+      transcript: data.text,
+      confidence: 1,
+      // OpenAI doesn't return confidence in standard response
+      language: data.language || request.language || "en"
+    };
+  }
+  async *synthesize(request) {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/audio/speech`, {
+      method: "POST",
+      body: JSON.stringify({
+        model: "tts-1",
+        input: request.text,
+        voice: request.voiceId || "alloy",
+        response_format: request.format || "mp3"
+      })
+    });
+    if (!response.body) throw new LemuraAdapterError("No response body for TTS", "STREAM_ERROR");
+    const reader = response.body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) {
+          const binary = new TextDecoder("latin1").decode(value);
+          yield { audioBase64: btoa(binary) };
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async describeImage(request) {
+    const payload = {
+      model: this.defaultModel,
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: request.prompt || "Describe this image" },
+            {
+              type: "image_url",
+              image_url: {
+                url: `data:image/jpeg;base64,${request.imageBase64}`
+              }
+            }
+          ]
+        }
+      ]
+    };
+    const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    });
+    const data = await response.json();
+    return {
+      description: data.choices[0].message.content,
+      objects: []
+      // OpenAI doesn't return structured objects in standard vision call
+    };
+  }
+  async generateImage(request) {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/images/generations`, {
+      method: "POST",
+      body: JSON.stringify({
+        prompt: request.prompt,
+        model: "dall-e-3",
+        n: 1,
+        size: request.dimensions || "1024x1024"
+      })
+    });
+    const data = await response.json();
+    return {
+      imageUrl: data.data[0].url,
+      revisedPrompt: data.data[0].revised_prompt
+    };
+  }
+};
+
+exports.OpenAICompatibleAdapter = OpenAICompatibleAdapter;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map