@stacksjs/ai 0.70.87 → 0.70.90

package/dist/drivers/ollama/index.js

@@ -0,0 +1,332 @@
+const DEFAULT_HOST = "http://localhost:11434", DEFAULT_MODEL = "llama3.2", DEFAULT_EMBEDDING_MODEL = "nomic-embed-text";
+let globalConfig = {};
+export function configure(config) {
+  globalConfig = { ...globalConfig, ...config };
+}
+function getConfig(config) {
+  return {
+    host: config?.host || globalConfig.host || process.env.OLLAMA_HOST || DEFAULT_HOST,
+    model: config?.model || globalConfig.model || process.env.OLLAMA_MODEL || DEFAULT_MODEL,
+    embeddingModel: config?.embeddingModel || globalConfig.embeddingModel || DEFAULT_EMBEDDING_MODEL
+  };
+}
+export function createOllamaDriver(config = {}) {
+  const {
+    host = process.env.OLLAMA_HOST || DEFAULT_HOST,
+    model = process.env.OLLAMA_MODEL || DEFAULT_MODEL,
+    embeddingModel = DEFAULT_EMBEDDING_MODEL
+  } = config;
+  return {
+    name: "Ollama",
+    async process(command, systemPrompt, history) {
+      const response = await fetch(`${host}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model,
+          messages: [
+            { role: "system", content: systemPrompt },
+            ...history,
+            { role: "user", content: command }
+          ],
+          stream: !1
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw Error(`Ollama API error: ${error}`);
+      }
+      return (await response.json()).message.content;
+    },
+    async* stream(command, systemPrompt, history) {
+      const response = await fetch(`${host}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model,
+          messages: [
+            { role: "system", content: systemPrompt },
+            ...history,
+            { role: "user", content: command }
+          ],
+          stream: !0
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw Error(`Ollama 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.trim())
+            continue;
+          try {
+            const data = JSON.parse(line);
+            if (data.message?.content)
+              yield data.message.content;
+          } catch {}
+        }
+      }
+    },
+    async embed(input) {
+      const inputs = Array.isArray(input) ? input : [input], embeddings = [];
+      for (const text of inputs) {
+        const response = await fetch(`${host}/api/embeddings`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            model: embeddingModel,
+            prompt: text
+          })
+        });
+        if (!response.ok) {
+          const error = await response.text();
+          throw Error(`Ollama Embeddings API error: ${error}`);
+        }
+        const data = await response.json();
+        embeddings.push(data.embedding);
+      }
+      return Array.isArray(input) ? embeddings : embeddings[0];
+    }
+  };
+}
+export async function chat(messages, options = {}) {
+  const config = getConfig(), {
+    model = config.model,
+    temperature,
+    topP,
+    stop
+  } = options, response = await fetch(`${config.host}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      messages,
+      stream: !1,
+      options: {
+        temperature,
+        top_p: topP,
+        stop
+      }
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`Ollama API error: ${error}`);
+  }
+  const data = await response.json();
+  return {
+    content: data.message.content,
+    model: data.model,
+    usage: {
+      promptTokens: data.prompt_eval_count || 0,
+      completionTokens: data.eval_count || 0,
+      totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+    },
+    finishReason: data.done_reason || "stop"
+  };
+}
+export async function* streamChat(messages, options = {}) {
+  const config = getConfig(), {
+    model = config.model,
+    temperature,
+    topP,
+    stop
+  } = options, response = await fetch(`${config.host}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      messages,
+      stream: !0,
+      options: {
+        temperature,
+        top_p: topP,
+        stop
+      }
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`Ollama 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.trim())
+        continue;
+      try {
+        const data = JSON.parse(line);
+        if (data.message?.content)
+          yield data.message.content;
+      } catch {}
+    }
+  }
+}
+export async function generate(prompt, options = {}) {
+  const config = getConfig(), response = await fetch(`${config.host}/api/generate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: options.model || config.model,
+      prompt,
+      system: options.system,
+      template: options.template,
+      context: options.context,
+      raw: options.raw,
+      format: options.format,
+      images: options.images,
+      stream: !1
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`Ollama API error: ${error}`);
+  }
+  const data = await response.json();
+  return {
+    content: data.response,
+    model: data.model,
+    usage: {
+      promptTokens: data.prompt_eval_count || 0,
+      completionTokens: data.eval_count || 0,
+      totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+    }
+  };
+}
+export async function embed(input, model) {
+  const config = getConfig(), embeddingModel = model || config.embeddingModel, inputs = Array.isArray(input) ? input : [input], embeddings = [];
+  for (const text of inputs) {
+    const response = await fetch(`${config.host}/api/embeddings`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: embeddingModel,
+        prompt: text
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw Error(`Ollama Embeddings API error: ${error}`);
+    }
+    const data = await response.json();
+    embeddings.push(data.embedding);
+  }
+  return Array.isArray(input) ? embeddings : embeddings[0];
+}
+export async function listModels() {
+  const config = getConfig(), response = await fetch(`${config.host}/api/tags`, {
+    method: "GET"
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`Ollama API error: ${error}`);
+  }
+  return (await response.json()).models;
+}
+export async function pullModel(name, onProgress) {
+  const config = getConfig(), response = await fetch(`${config.host}/api/pull`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name, stream: !0 })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`Ollama API error: ${error}`);
+  }
+  const reader = response.body?.getReader();
+  if (!reader)
+    return;
+  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.trim())
+        continue;
+      try {
+        const data = JSON.parse(line);
+        if (onProgress)
+          onProgress(data.status ?? "", data.completed, data.total);
+      } catch {}
+    }
+  }
+}
+export async function deleteModel(name) {
+  const config = getConfig(), response = await fetch(`${config.host}/api/delete`, {
+    method: "DELETE",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`Ollama API error: ${error}`);
+  }
+}
+export async function showModel(_name) {
+  const config = getConfig(), response = await fetch(`${config.host}/api/show`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name: _name })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`Ollama API error: ${error}`);
+  }
+  return response.json();
+}
+export async function isRunning() {
+  const config = getConfig();
+  try {
+    return (await fetch(`${config.host}/api/tags`, {
+      method: "GET"
+    })).ok;
+  } catch {
+    return !1;
+  }
+}
+export const ollamaDriver = {
+  create: createOllamaDriver
+}, ollama = {
+  configure,
+  chat,
+  streamChat,
+  generate,
+  embed,
+  listModels,
+  pullModel,
+  deleteModel,
+  showModel,
+  isRunning,
+  createDriver: createOllamaDriver
+};
+export default ollama;

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;