@stacksjs/ai 0.70.88 → 0.70.91

package/dist/drivers/openai/index.js

@@ -0,0 +1,351 @@
+import { fetchWithRetry } from "../../utils/retry";
+import { recordUsage } from "../../utils/usage";
+import { normalizeMessagesForProvider } from "../../utils/vision";
+const DEFAULT_MODEL = "gpt-4o", DEFAULT_MAX_TOKENS = 4096, DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small", DEFAULT_BASE_URL = "https://api.openai.com/v1";
+let globalConfig = null;
+export function configure(config) {
+  globalConfig = config;
+}
+function getConfig(config) {
+  const merged = { ...globalConfig, ...config };
+  if (!merged.apiKey)
+    merged.apiKey = process.env.OPENAI_API_KEY || "";
+  return merged;
+}
+export function createOpenAIDriver(config) {
+  const {
+    apiKey,
+    model = DEFAULT_MODEL,
+    maxTokens = DEFAULT_MAX_TOKENS,
+    baseUrl = DEFAULT_BASE_URL,
+    embeddingModel = DEFAULT_EMBEDDING_MODEL
+  } = config;
+  return {
+    name: "OpenAI",
+    async process(command, systemPrompt, history) {
+      if (!apiKey)
+        throw Error("OpenAI API key not set. Configure your API key in settings.");
+      const response = await fetchWithRetry(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: maxTokens,
+          messages: [
+            { role: "system", content: systemPrompt },
+            ...history,
+            { role: "user", content: command }
+          ]
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw Error(`OpenAI API error: ${error}`);
+      }
+      const data = await response.json();
+      if (!data.choices || data.choices.length === 0)
+        throw Error("OpenAI API returned empty choices");
+      return data.choices[0].message.content;
+    },
+    async* stream(command, systemPrompt, history) {
+      if (!apiKey)
+        throw Error("OpenAI API key not set. Configure your API key in settings.");
+      const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: maxTokens,
+          stream: !0,
+          messages: [
+            { role: "system", content: systemPrompt },
+            ...history,
+            { role: "user", content: command }
+          ]
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw Error(`OpenAI API error: ${error}`);
+      }
+      const reader = response.body?.getReader();
+      if (!reader)
+        throw Error("No response body");
+      const decoder = new TextDecoder;
+      let buffer = "";
+      const handlePayload = function* (data) {
+        if (data === "[DONE]")
+          return;
+        let parsed;
+        try {
+          parsed = JSON.parse(data);
+        } catch {
+          return;
+        }
+        if (parsed?.error) {
+          const msg = parsed.error.message || JSON.stringify(parsed.error);
+          throw Error(`[openai/stream] mid-stream error: ${msg}`);
+        }
+        const content = parsed.choices?.[0]?.delta?.content;
+        if (content)
+          yield content;
+      };
+      while (!0) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: !0 });
+        const lines = buffer.split(`
+`);
+        buffer = lines.pop() || "";
+        for (const line of lines)
+          if (line.startsWith("data: "))
+            yield* handlePayload(line.slice(6));
+      }
+      if (buffer.startsWith("data: "))
+        yield* handlePayload(buffer.slice(6));
+    },
+    async embed(input) {
+      if (!apiKey)
+        throw Error("OpenAI API key not set. Configure your API key in settings.");
+      const response = await fetch(`${baseUrl}/embeddings`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model: embeddingModel,
+          input
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw Error(`OpenAI Embeddings API error: ${error}`);
+      }
+      const data = await response.json();
+      if (Array.isArray(input))
+        return data.data.map((d) => d.embedding);
+      return data.data[0].embedding;
+    }
+  };
+}
+export async function chat(messages, options = {}) {
+  const config = getConfig(), {
+    model = DEFAULT_MODEL,
+    maxTokens = DEFAULT_MAX_TOKENS,
+    temperature,
+    topP,
+    stop
+  } = options, normalizedMessages = normalizeMessagesForProvider(messages, "openai"), startedAt = Date.now(), response = await fetchWithRetry(`${config.baseUrl || DEFAULT_BASE_URL}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: maxTokens,
+      temperature,
+      top_p: topP,
+      stop,
+      messages: normalizedMessages
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`OpenAI API error: ${error}`);
+  }
+  const data = await response.json();
+  if (!data.choices || data.choices.length === 0)
+    throw Error("OpenAI API returned empty choices");
+  const result = {
+    content: data.choices[0].message.content,
+    model: data.model,
+    usage: {
+      promptTokens: data.usage?.prompt_tokens || 0,
+      completionTokens: data.usage?.completion_tokens || 0,
+      totalTokens: data.usage?.total_tokens || 0
+    },
+    finishReason: data.choices[0].finish_reason
+  };
+  recordUsage({
+    provider: "openai",
+    model: data.model,
+    promptTokens: result.usage.promptTokens,
+    completionTokens: result.usage.completionTokens,
+    totalTokens: result.usage.totalTokens,
+    durationMs: Date.now() - startedAt,
+    timestamp: Date.now()
+  });
+  return result;
+}
+export async function* streamChat(messages, options = {}) {
+  const config = getConfig(), {
+    model = DEFAULT_MODEL,
+    maxTokens = DEFAULT_MAX_TOKENS,
+    temperature,
+    topP,
+    stop
+  } = options, response = await fetch(`${config.baseUrl || DEFAULT_BASE_URL}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: maxTokens,
+      temperature,
+      top_p: topP,
+      stop,
+      stream: !0,
+      messages: normalizeMessagesForProvider(messages, "openai")
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`OpenAI API error: ${error}`);
+  }
+  const reader = response.body?.getReader();
+  if (!reader)
+    throw Error("No response body");
+  const decoder = new TextDecoder;
+  let buffer = "";
+  while (!0) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: !0 });
+    const lines = buffer.split(`
+`);
+    buffer = lines.pop() || "";
+    for (const line of lines)
+      if (line.startsWith("data: ")) {
+        const data = line.slice(6);
+        if (data === "[DONE]")
+          continue;
+        try {
+          const content = JSON.parse(data).choices[0]?.delta?.content;
+          if (content)
+            yield content;
+        } catch {}
+      }
+  }
+}
+export async function embed(input, model = DEFAULT_EMBEDDING_MODEL) {
+  const config = getConfig(), response = await fetch(`${config.baseUrl || DEFAULT_BASE_URL}/embeddings`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`
+    },
+    body: JSON.stringify({ model, input })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`OpenAI Embeddings API error: ${error}`);
+  }
+  const data = await response.json();
+  if (Array.isArray(input))
+    return data.data.map((d) => d.embedding);
+  return data.data[0].embedding;
+}
+export async function generateImage(prompt, options = {}) {
+  const config = getConfig(), {
+    model = "dall-e-3",
+    size = "1024x1024",
+    quality = "standard",
+    n = 1,
+    responseFormat = "url"
+  } = options, response = await fetch(`${config.baseUrl || DEFAULT_BASE_URL}/images/generations`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      prompt,
+      size,
+      quality,
+      n,
+      response_format: responseFormat
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`OpenAI Image API error: ${error}`);
+  }
+  return (await response.json()).data;
+}
+export async function transcribe(audioFile, options = {}) {
+  const config = getConfig(), formData = new FormData;
+  formData.append("file", audioFile);
+  formData.append("model", options.model || "whisper-1");
+  if (options.language)
+    formData.append("language", options.language);
+  if (options.prompt)
+    formData.append("prompt", options.prompt);
+  if (options.responseFormat)
+    formData.append("response_format", options.responseFormat);
+  if (options.temperature !== void 0)
+    formData.append("temperature", String(options.temperature));
+  const response = await fetch(`${config.baseUrl || DEFAULT_BASE_URL}/audio/transcriptions`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`
+    },
+    body: formData
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`OpenAI Whisper API error: ${error}`);
+  }
+  return response.json();
+}
+export async function textToSpeech(input, options = {}) {
+  const config = getConfig(), {
+    model = "tts-1",
+    voice = "alloy",
+    responseFormat = "mp3",
+    speed = 1
+  } = options, response = await fetch(`${config.baseUrl || DEFAULT_BASE_URL}/audio/speech`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      input,
+      voice,
+      response_format: responseFormat,
+      speed
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`OpenAI TTS API error: ${error}`);
+  }
+  return response.arrayBuffer();
+}
+export const openaiDriver = {
+  create: createOpenAIDriver
+}, openai = {
+  configure,
+  chat,
+  streamChat,
+  embed,
+  generateImage,
+  transcribe,
+  textToSpeech,
+  createDriver: createOpenAIDriver
+};
+export default openai;

package/dist/image.d.ts

@@ -0,0 +1,83 @@
+import type { AIResult } from './types';
+/**
+ * Generate images from a text prompt.
+ * Currently supports OpenAI DALL-E models.
+ */
+export declare function generateImage(prompt: string, options?: ImageGenerationOptions): Promise<ImageGenerationResult>;
+/**
+ * Edit an existing image with a text prompt (OpenAI DALL-E 2).
+ */
+export declare function editImage(image: Blob | File, prompt: string, options?: ImageEditOptions): Promise<ImageGenerationResult>;
+/**
+ * Create variations of an existing image (OpenAI DALL-E 2).
+ */
+export declare function createImageVariation(image: Blob | File, options?: {
+    model?: 'dall-e-2'
+    n?: number
+    size?: '256x256' | '512x512' | '1024x1024'
+    responseFormat?: 'url' | 'b64_json'
+  }): Promise<ImageGenerationResult>;
+/**
+ * Analyze an image using AI vision capabilities.
+ * Supports Anthropic Claude, OpenAI GPT-4V, and Ollama multimodal models.
+ */
+export declare function analyzeImage(imageInput: ImageInput, prompt: string, options?: VisionOptions): Promise<VisionResult>;
+/**
+ * Analyze multiple images together with a prompt.
+ * Useful for comparison, batch analysis, etc.
+ */
+export declare function analyzeImages(images: ImageInput[], prompt: string, options?: VisionOptions): Promise<VisionResult>;
+// ============================================================================
+// Exports
+// ============================================================================
+export declare const image: {
+  generate: unknown;
+  edit: unknown;
+  variation: unknown;
+  analyze: unknown;
+  analyzeMultiple: unknown
+};
+// ============================================================================
+// Types
+// ============================================================================
+export declare interface ImageGenerationOptions {
+  provider?: 'openai' | 'ollama'
+  model?: string
+  size?: '256x256' | '512x512' | '1024x1024' | '1792x1024' | '1024x1792'
+  quality?: 'standard' | 'hd'
+  n?: number
+  responseFormat?: 'url' | 'b64_json'
+  style?: 'vivid' | 'natural'
+}
+export declare interface ImageGenerationResult {
+  images: Array<{
+    url?: string
+    b64_json?: string
+    revisedPrompt?: string
+  }>
+  provider: string
+  model: string
+}
+export declare interface VisionOptions {
+  provider?: 'anthropic' | 'openai' | 'ollama'
+  model?: string
+  maxTokens?: number
+  temperature?: number
+  detail?: 'auto' | 'low' | 'high'
+}
+export declare interface VisionResult extends AIResult {
+  provider: string
+}
+// ============================================================================
+// Image Editing
+// ============================================================================
+export declare interface ImageEditOptions {
+  mask?: Blob | File
+  model?: 'dall-e-2'
+  n?: number
+  size?: '256x256' | '512x512' | '1024x1024'
+  responseFormat?: 'url' | 'b64_json'
+}
+export type ImageInput = | { type: 'url'; url: string }
+  | { type: 'base64'; data: string; mediaType: string }
+  | { type: 'file'; path: string }