@stacksjs/ai 0.70.87 → 0.70.90

package/dist/search.js

@@ -0,0 +1,316 @@
+export async function createEmbedding(input, options = {}) {
+  const { provider = "openai" } = options;
+  if (provider === "openai")
+    return createEmbeddingOpenAI(input, options.model || "text-embedding-3-small");
+  if (provider === "ollama")
+    return createEmbeddingOllama(input, options.model || "nomic-embed-text");
+  throw Error(`Embedding provider not supported: ${provider}`);
+}
+async function createEmbeddingOpenAI(input, model) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey)
+    throw Error("OPENAI_API_KEY environment variable is required for embeddings.");
+  const response = await fetch("https://api.openai.com/v1/embeddings", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${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);
+  const first = data.data[0];
+  if (!first)
+    throw Error("OpenAI Embeddings API returned no embedding");
+  return first.embedding;
+}
+async function createEmbeddingOllama(input, model) {
+  const host = process.env.OLLAMA_HOST || "http://localhost:11434", 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, 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);
+  }
+  if (Array.isArray(input))
+    return embeddings;
+  const first = embeddings[0];
+  if (!first)
+    throw Error("Ollama Embeddings API returned no embedding");
+  return first;
+}
+export function cosineSimilarity(a, b) {
+  if (a.length !== b.length)
+    throw Error(`Vector dimensions must match: ${a.length} vs ${b.length}`);
+  let dotProduct = 0, normA = 0, normB = 0;
+  for (let i = 0;i < a.length; i++) {
+    const av = a[i], bv = b[i];
+    dotProduct += av * bv;
+    normA += av * av;
+    normB += bv * bv;
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denominator === 0)
+    return 0;
+  return dotProduct / denominator;
+}
+export function dotProduct(a, b) {
+  if (a.length !== b.length)
+    throw Error(`Vector dimensions must match: ${a.length} vs ${b.length}`);
+  let result = 0;
+  for (let i = 0;i < a.length; i++)
+    result += a[i] * b[i];
+  return result;
+}
+export function euclideanDistance(a, b) {
+  if (a.length !== b.length)
+    throw Error(`Vector dimensions must match: ${a.length} vs ${b.length}`);
+  let sum = 0;
+  for (let i = 0;i < a.length; i++) {
+    const diff = a[i] - b[i];
+    sum += diff * diff;
+  }
+  return Math.sqrt(sum);
+}
+
+export class VectorIndex {
+  documents = [];
+  embeddingOptions;
+  constructor(options = {}) {
+    this.embeddingOptions = options;
+  }
+  async add(documents) {
+    if (documents.length === 0)
+      return;
+    const contents = documents.map((d) => d.content), embeddings = await createEmbedding(contents, this.embeddingOptions);
+    for (let i = 0;i < documents.length; i++) {
+      const document = documents[i], embedding = embeddings[i];
+      if (!document || !embedding)
+        continue;
+      this.documents.push({
+        ...document,
+        embedding
+      });
+    }
+  }
+  addWithEmbedding(document, embedding) {
+    this.documents.push({ ...document, embedding });
+  }
+  async search(query, topK = 5) {
+    if (this.documents.length === 0)
+      return [];
+    const queryEmbedding = await createEmbedding(query, this.embeddingOptions);
+    return this.searchByVector(queryEmbedding, topK);
+  }
+  searchByVector(queryEmbedding, topK = 5) {
+    if (this.documents.length === 0)
+      return [];
+    const scored = this.documents.map((doc) => ({
+      document: { id: doc.id, content: doc.content, metadata: doc.metadata },
+      score: cosineSimilarity(queryEmbedding, doc.embedding)
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, topK).map((result, index) => ({
+      ...result,
+      rank: index + 1
+    }));
+  }
+  remove(id) {
+    const initialLength = this.documents.length;
+    this.documents = this.documents.filter((d) => d.id !== id);
+    return this.documents.length < initialLength;
+  }
+  clear() {
+    this.documents = [];
+  }
+  get size() {
+    return this.documents.length;
+  }
+  get ids() {
+    return this.documents.map((d) => d.id);
+  }
+}
+export async function rag(query, index, options = {}) {
+  const {
+    provider = "anthropic",
+    topK = 5,
+    maxTokens = 4096,
+    temperature,
+    systemPrompt
+  } = options, searchResults = await index.search(query, topK), contextText = searchResults.map((r, i) => `[Source ${i + 1}] (score: ${r.score.toFixed(3)})
+${r.document.content}`).join(`
+
+---
+
+`), ragSystemPrompt = systemPrompt || "You are a helpful assistant. Answer the user's question based on the provided context. If the context doesn't contain relevant information, say so. Always cite your sources by referencing [Source N].", fullPrompt = `Context:
+${contextText}
+
+Question: ${query}`;
+  if (provider === "anthropic")
+    return ragWithAnthropic(fullPrompt, ragSystemPrompt, searchResults, { maxTokens, temperature, model: options.model });
+  if (provider === "openai")
+    return ragWithOpenAI(fullPrompt, ragSystemPrompt, searchResults, { maxTokens, temperature, model: options.model });
+  if (provider === "ollama")
+    return ragWithOllama(fullPrompt, ragSystemPrompt, searchResults, { maxTokens, temperature, model: options.model });
+  throw Error(`RAG provider not supported: ${provider}`);
+}
+async function ragWithAnthropic(prompt, systemPrompt, sources, options) {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey)
+    throw Error("ANTHROPIC_API_KEY required for RAG with Anthropic.");
+  const model = options.model || "claude-sonnet-4-20250514", response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: options.maxTokens || 4096,
+      temperature: options.temperature,
+      system: systemPrompt,
+      messages: [{ role: "user", content: prompt }]
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`Claude API error: ${error}`);
+  }
+  const data = await response.json();
+  return {
+    content: data.content[0].text,
+    model: data.model,
+    usage: {
+      promptTokens: data.usage?.input_tokens || 0,
+      completionTokens: data.usage?.output_tokens || 0,
+      totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0)
+    },
+    finishReason: data.stop_reason,
+    sources
+  };
+}
+async function ragWithOpenAI(prompt, systemPrompt, sources, options) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey)
+    throw Error("OPENAI_API_KEY required for RAG with OpenAI.");
+  const model = options.model || "gpt-4o", response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: options.maxTokens || 4096,
+      temperature: options.temperature,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: prompt }
+      ]
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`OpenAI API error: ${error}`);
+  }
+  const data = await response.json();
+  return {
+    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,
+    sources
+  };
+}
+async function ragWithOllama(prompt, systemPrompt, sources, options) {
+  const host = process.env.OLLAMA_HOST || "http://localhost:11434", model = options.model || "llama3.2", response = await fetch(`${host}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: prompt }
+      ],
+      stream: !1,
+      options: {
+        temperature: options.temperature
+      }
+    })
+  });
+  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",
+    sources
+  };
+}
+export function chunkText(text, options = {}) {
+  const {
+    chunkSize = 1000,
+    chunkOverlap = 200,
+    separator = `
+`
+  } = options, segments = text.split(separator), chunks = [];
+  let currentChunk = "";
+  for (const segment of segments)
+    if (currentChunk.length + segment.length + 1 > chunkSize && currentChunk.length > 0) {
+      chunks.push(currentChunk.trim());
+      if (chunkOverlap > 0) {
+        const overlapStart = Math.max(0, currentChunk.length - chunkOverlap);
+        currentChunk = currentChunk.slice(overlapStart) + separator + segment;
+      } else
+        currentChunk = segment;
+    } else
+      currentChunk += (currentChunk ? separator : "") + segment;
+  if (currentChunk.trim())
+    chunks.push(currentChunk.trim());
+  return chunks;
+}
+export async function indexText(text, options = {}) {
+  const chunks = chunkText(text, options), index = new VectorIndex(options), documents = chunks.map((chunk, i) => ({
+    id: `${options.idPrefix || "chunk"}-${i}`,
+    content: chunk,
+    metadata: { chunkIndex: i, totalChunks: chunks.length }
+  }));
+  await index.add(documents);
+  return index;
+}
+export const search = {
+  createEmbedding,
+  cosineSimilarity,
+  dotProduct,
+  euclideanDistance,
+  VectorIndex,
+  rag,
+  chunkText,
+  indexText
+};

package/dist/text.js

@@ -0,0 +1,51 @@
+import { invokeModel } from "./utils/client-bedrock-runtime";
+const DEFAULT_MODEL = "amazon.titan-text-express-v1";
+function resolveModel(override) {
+  if (override)
+    return override;
+  return globalThis.config?.ai?.bedrock?.model || process.env.BEDROCK_MODEL_ID || DEFAULT_MODEL;
+}
+export async function summarize(text, options = {}) {
+  const { maxTokenCount = 512, temperature = 0, topP = 0.9, modelId } = options;
+  try {
+    const response = await invokeModel({
+      modelId: resolveModel(modelId),
+      contentType: "application/json",
+      accept: "*/*",
+      body: JSON.stringify({
+        inputText: `Summarize the following text: ${text}`,
+        textGenerationConfig: {
+          maxTokenCount,
+          stopSequences: [],
+          temperature,
+          topP
+        }
+      })
+    });
+    return JSON.parse(new TextDecoder().decode(response.body)).results[0].outputText;
+  } catch (error) {
+    throw Error(`Error summarizing text: ${error.message}`);
+  }
+}
+export async function ask(question, options = {}) {
+  const { maxTokenCount = 512, temperature = 0, topP = 0.9, modelId } = options;
+  try {
+    const response = await invokeModel({
+      modelId: resolveModel(modelId),
+      contentType: "application/json",
+      accept: "*/*",
+      body: JSON.stringify({
+        inputText: question,
+        textGenerationConfig: {
+          maxTokenCount,
+          stopSequences: [],
+          temperature,
+          topP
+        }
+      })
+    });
+    return JSON.parse(new TextDecoder().decode(response.body)).results[0].outputText;
+  } catch (error) {
+    throw Error(`Error asking question: ${error.message}`);
+  }
+}

package/dist/utils/client-bedrock-runtime.js

@@ -0,0 +1,17 @@
+import process from "node:process";
+let _client = null;
+async function getClient() {
+  if (_client)
+    return _client;
+  const mod = await import("@stacksjs/ts-cloud/aws");
+  if (!mod?.BedrockRuntimeClient)
+    throw Error("@stacksjs/ts-cloud/aws does not export BedrockRuntimeClient \u2014 rebuild ts-cloud or remove the AI dependency.");
+  _client = new mod.BedrockRuntimeClient(process.env.REGION || "us-east-1");
+  return _client;
+}
+export async function invokeModel(params) {
+  return (await getClient()).invokeModel(params);
+}
+export async function invokeModelWithResponseStream(params) {
+  return (await getClient()).invokeModelWithResponseStream(params);
+}

package/dist/utils/client-bedrock.js

@@ -0,0 +1,20 @@
+import process from "node:process";
+let _client = null;
+async function getClient() {
+  if (_client)
+    return _client;
+  const mod = await import("@stacksjs/ts-cloud/aws");
+  if (!mod?.BedrockClient)
+    throw Error("@stacksjs/ts-cloud/aws does not export BedrockClient \u2014 rebuild ts-cloud or remove the AI dependency.");
+  _client = new mod.BedrockClient(process.env.REGION || "us-east-1");
+  return _client;
+}
+export async function createModelCustomizationJob(param) {
+  return (await getClient()).createModelCustomizationJob(param);
+}
+export async function getModelCustomizationJob(params) {
+  return (await getClient()).getModelCustomizationJob(params);
+}
+export async function listFoundationModels(params) {
+  return (await getClient()).listFoundationModels(params);
+}

package/dist/utils/model-access.js

@@ -0,0 +1,21 @@
+import { log } from "@stacksjs/cli";
+import { ai } from "@stacksjs/config";
+async function getBedrockClient() {
+  const mod = await import("@stacksjs/ts-cloud/aws");
+  if (!mod?.BedrockClient)
+    throw Error("@stacksjs/ts-cloud/aws does not export BedrockClient \u2014 rebuild ts-cloud or remove the AI dependency.");
+  return new mod.BedrockClient("us-east-1");
+}
+export async function requestModelAccess() {
+  const client = await getBedrockClient(), models = ai.models;
+  if (!models)
+    throw Error("No AI models found. Please set ./config/ai.ts values.");
+  for (const model of models)
+    try {
+      log.info(`Requesting access to model ${model}`);
+      const data = await client.requestModelAccess({ modelId: model });
+      log.info(`Response for model ${model}:`, data);
+    } catch (error) {
+      log.error(`Error requesting access to model ${model}:`, error);
+    }
+}

package/dist/utils/retry.js

@@ -0,0 +1,39 @@
+const DEFAULT_RETRY = {
+  maxRetries: 3,
+  baseDelayMs: 500,
+  maxDelayMs: 30000
+};
+export async function fetchWithRetry(input, init, config = {}) {
+  const cfg = { ...DEFAULT_RETRY, ...config };
+  let lastResponse;
+  for (let attempt = 0;attempt <= cfg.maxRetries; attempt++) {
+    lastResponse = await fetch(input, init);
+    if (lastResponse.ok)
+      return lastResponse;
+    if (lastResponse.status < 500 && lastResponse.status !== 429)
+      return lastResponse;
+    if (attempt === cfg.maxRetries)
+      return lastResponse;
+    const backoff = parseRetryAfter(lastResponse.headers.get("Retry-After")) ?? exponentialBackoff(attempt, cfg), delay = Math.min(backoff, cfg.maxDelayMs);
+    try {
+      await lastResponse.text().catch(() => {});
+    } catch {}
+    await new Promise((resolve) => setTimeout(resolve, delay));
+  }
+  return lastResponse;
+}
+function parseRetryAfter(header) {
+  if (!header)
+    return null;
+  const seconds = Number.parseInt(header, 10);
+  if (Number.isFinite(seconds) && String(seconds) === header.trim())
+    return Math.max(0, seconds * 1000);
+  const dateMs = Date.parse(header);
+  if (Number.isFinite(dateMs))
+    return Math.max(0, dateMs - Date.now());
+  return null;
+}
+function exponentialBackoff(attempt, cfg) {
+  const cap = Math.min(cfg.baseDelayMs * 2 ** attempt, cfg.maxDelayMs);
+  return Math.random() * cap;
+}

package/dist/utils/tokens.js

@@ -0,0 +1,59 @@
+function charsPerToken(model) {
+  const m = model.toLowerCase();
+  if (m.startsWith("gpt-"))
+    return 3.5;
+  if (m.startsWith("claude"))
+    return 3.5;
+  return 3.5;
+}
+export function estimateTokens(text, model = "gpt-4o") {
+  if (!text)
+    return 0;
+  const ratio = charsPerToken(model);
+  return Math.max(1, Math.ceil(text.length / ratio));
+}
+export function estimateMessageTokens(messages, model = "gpt-4o") {
+  const PER_MESSAGE_OVERHEAD = 4;
+  let total = 2;
+  for (const msg of messages) {
+    total += PER_MESSAGE_OVERHEAD;
+    if (typeof msg.content === "string")
+      total += estimateTokens(msg.content, model);
+    else if (Array.isArray(msg.content)) {
+      for (const block of msg.content)
+        if (block.type === "text" && block.text)
+          total += estimateTokens(block.text, model);
+        else if (block.type === "image" || block.type === "image_url")
+          total += 100;
+    }
+  }
+  return total;
+}
+const INJECTION_PATTERNS = [
+  /\bignore\s+(?:all\s+)?(?:previous|prior|above)\s+instructions?\b/i,
+  /\bdisregard\s+(?:all\s+)?(?:previous|prior|above)\b/i,
+  /\bforget\s+(?:everything|all)\s+(?:you|i)\b/i,
+  /\byou\s+are\s+now\s+a\s+\w+/i,
+  /\bnew\s+instructions?:\s*/i,
+  /\bsystem\s*[:>]\s*/i,
+  /\b(?:reveal|show|print|output|display)\s+(?:your|the)\s+(?:system\s+)?prompt\b/i,
+  /<\s*\/?\s*system\s*>/i,
+  /\[INST\]|\[\/INST\]/i,
+  /^\s*###\s+(?:instruction|system)/im
+];
+export function sanitizePrompt(text) {
+  if (!text)
+    return { ok: !0, matched: [], cleaned: text };
+  const matched = [];
+  let cleaned = text;
+  for (const pattern of INJECTION_PATTERNS)
+    if (pattern.test(cleaned)) {
+      matched.push(pattern.toString());
+      cleaned = cleaned.replace(pattern, "[redacted]");
+    }
+  return {
+    ok: matched.length === 0,
+    matched,
+    cleaned
+  };
+}

package/dist/utils/usage.js

@@ -0,0 +1,27 @@
+const reporters = [];
+export function onUsage(reporter) {
+  reporters.push(reporter);
+  return () => {
+    const idx = reporters.indexOf(reporter);
+    if (idx >= 0)
+      reporters.splice(idx, 1);
+  };
+}
+export function clearUsageReporters() {
+  reporters.length = 0;
+}
+export function recordUsage(record) {
+  for (const reporter of reporters)
+    try {
+      const result = reporter(record);
+      if (result && typeof result.then === "function")
+        result.catch((err) => {
+          console.error("[ai/usage] reporter rejected:", err);
+        });
+    } catch (err) {
+      console.error("[ai/usage] reporter threw:", err);
+    }
+}
+export function listUsageReporters() {
+  return reporters;
+}

package/dist/utils/vision.js

@@ -0,0 +1,54 @@
+function toOpenAIContent(block) {
+  if (block.type === "text")
+    return { type: "text", text: block.text ?? "" };
+  if (block.type === "image_url")
+    return { type: "image_url", image_url: block.image_url };
+  if (block.type === "image" && block.source) {
+    if (block.source.type === "base64")
+      return { type: "image_url", image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` } };
+  }
+  return block;
+}
+function toAnthropicContent(block) {
+  if (block.type === "text")
+    return { type: "text", text: block.text ?? "" };
+  if (block.type === "image" && block.source)
+    return { type: "image", source: block.source };
+  if (block.type === "image_url" && block.image_url) {
+    const url = block.image_url.url, dataMatch = url.match(/^data:([^;]+);base64,(.+)$/);
+    if (dataMatch)
+      return {
+        type: "image",
+        source: { type: "base64", media_type: dataMatch[1], data: dataMatch[2] }
+      };
+    return { type: "image", source: { type: "url", url } };
+  }
+  return block;
+}
+export function normalizeMessagesForProvider(messages, provider) {
+  return messages.map((msg) => {
+    if (typeof msg.content === "string")
+      return msg;
+    const mapper = provider === "openai" ? toOpenAIContent : toAnthropicContent;
+    return {
+      role: msg.role,
+      content: msg.content.map(mapper)
+    };
+  });
+}
+export function buildMessageWithImages(command, images) {
+  const blocks = [];
+  for (const img of images)
+    if (img.dataBase64 && img.mediaType)
+      blocks.push({
+        type: "image",
+        source: { type: "base64", media_type: img.mediaType, data: img.dataBase64 }
+      });
+    else if (img.url)
+      blocks.push({
+        type: "image_url",
+        image_url: { url: img.url, detail: img.detail }
+      });
+  blocks.push({ type: "text", text: command });
+  return blocks;
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/ai",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.87",
+  "version": "0.70.90",
   "description": "Stacks Artificial Intelligence.",
   "author": "Chris Breuer",
   "contributors": [