@stacksjs/ai 0.70.88 → 0.70.90

package/dist/personalization.js

@@ -0,0 +1,244 @@
+export async function analyzeSentiment(text, options = {}) {
+  const { provider = "anthropic", aspects } = options, aspectInstruction = aspects ? `
+Also analyze sentiment for these specific aspects: ${aspects.join(", ")}` : "", systemPrompt = `You are a sentiment analysis expert. Analyze the sentiment of the given text and respond with ONLY valid JSON in this exact format:
+{
+  "sentiment": "positive" | "negative" | "neutral" | "mixed",
+  "score": <number from -1.0 to 1.0>,
+  "confidence": <number from 0.0 to 1.0>${aspects ? `,
+  "aspects": [{"aspect": "<name>", "sentiment": "positive" | "negative" | "neutral", "score": <number>}]` : ""}
+}${aspectInstruction}`, result = await callProvider(provider, systemPrompt, text, options.model);
+  try {
+    return JSON.parse(result.content);
+  } catch {
+    const lower = result.content.toLowerCase(), isPositive = lower.includes("positive"), isNegative = lower.includes("negative");
+    return {
+      sentiment: isPositive && isNegative ? "mixed" : isPositive ? "positive" : isNegative ? "negative" : "neutral",
+      score: isPositive ? 0.5 : isNegative ? -0.5 : 0,
+      confidence: 0.5
+    };
+  }
+}
+export async function classifyText(text, labels, options = {}) {
+  const { provider = "anthropic", multiLabel = !1 } = options, systemPrompt = `You are a text classification expert. Classify the given text into ${multiLabel ? "one or more of" : "exactly one of"} these categories: ${labels.join(", ")}.
+
+Respond with ONLY valid JSON in this exact format:
+{
+  "label": "<primary label>",
+  "confidence": <number from 0.0 to 1.0>,
+  "allLabels": [{"label": "<label>", "confidence": <number>}]
+}
+
+Include ALL provided labels in allLabels with their confidence scores, sorted by confidence descending.`, result = await callProvider(provider, systemPrompt, text, options.model);
+  try {
+    return JSON.parse(result.content);
+  } catch {
+    return {
+      label: labels[0] ?? "",
+      confidence: 0.5,
+      allLabels: labels.map((l) => ({ label: l, confidence: 1 / labels.length }))
+    };
+  }
+}
+async function summarize(text, options = {}) {
+  const {
+    provider = "anthropic",
+    style = "concise",
+    maxLength,
+    language
+  } = options;
+  let styleInstruction;
+  switch (style) {
+    case "bullet-points":
+      styleInstruction = "Use bullet points to organize the key points.";
+      break;
+    case "detailed":
+      styleInstruction = "Provide a detailed summary covering all major points.";
+      break;
+    default:
+      styleInstruction = "Be concise and focus on the most important points.";
+  }
+  const lengthInstruction = maxLength ? ` Keep the summary under ${maxLength} words.` : "", languageInstruction = language ? ` Write the summary in ${language}.` : "", systemPrompt = `You are an expert summarizer. ${styleInstruction}${lengthInstruction}${languageInstruction}`;
+  return callProvider(provider, systemPrompt, `Summarize the following text:
+
+${text}`, options.model);
+}
+export async function recommend(profile, items, options = {}) {
+  const { provider = "anthropic", limit = 5 } = options, profileSummary = buildProfileSummary(profile), itemsList = items.map((item) => `ID: ${item.id} | Category: ${item.category || "none"} | Tags: ${item.tags?.join(", ") || "none"} | Content: ${item.content.slice(0, 200)}`).join(`
+`), systemPrompt = `You are a recommendation engine. Based on the user profile, recommend the most relevant items. Respond with ONLY valid JSON:
+{
+  "recommendations": [
+    {"itemId": "<id>", "score": <0.0-1.0>, "reason": "<brief reason>"}
+  ]
+}
+
+Return at most ${limit} recommendations, sorted by relevance score descending.`, prompt = `User Profile:
+${profileSummary}
+
+Available Items:
+${itemsList}`, result = await callProvider(provider, systemPrompt, prompt, options.model);
+  try {
+    return {
+      recommendations: JSON.parse(result.content).recommendations.slice(0, limit),
+      model: result.model,
+      provider
+    };
+  } catch {
+    return {
+      recommendations: [],
+      model: result.model,
+      provider
+    };
+  }
+}
+function buildProfileSummary(profile) {
+  const topPreferences = Object.entries(profile.preferences).sort(([, a], [, b]) => b - a).slice(0, 10).map(([key, value]) => `${key}: ${value.toFixed(2)}`).join(", "), recentInteractions = profile.interactions.sort((a, b) => b.timestamp - a.timestamp).slice(0, 10).map((i) => `${i.type} on ${i.itemId}`).join(", ");
+  return `Segments: ${profile.segments.join(", ")}
+Top Preferences: ${topPreferences || "none"}
+Recent Interactions: ${recentInteractions || "none"}`;
+}
+export function createProfile(id, segments = []) {
+  return {
+    id,
+    preferences: {},
+    interactions: [],
+    segments
+  };
+}
+export function recordInteraction(profile, interaction) {
+  profile.interactions.push(interaction);
+  const weight = {
+    view: 0.1,
+    click: 0.3,
+    like: 0.5,
+    share: 0.6,
+    bookmark: 0.7,
+    purchase: 1,
+    dislike: -0.5,
+    custom: interaction.weight || 0.3
+  }[interaction.type] || 0.1, key = interaction.itemId;
+  profile.preferences[key] = (profile.preferences[key] || 0) + weight;
+  return profile;
+}
+export async function extractUserInterests(profile, items, options = {}) {
+  const { provider = "anthropic" } = options, interactedItemIds = new Set(profile.interactions.map((i) => i.itemId)), interactedItems = items.filter((item) => interactedItemIds.has(item.id));
+  if (interactedItems.length === 0)
+    return profile.segments;
+  const contentSample = interactedItems.slice(0, 20).map((item) => item.content.slice(0, 200)).join(`
+---
+`), result = await callProvider(provider, `Extract the main interests/topics from the user's interaction history. Return ONLY a JSON array of strings, e.g. ["technology", "cooking", "travel"]. Maximum 10 interests.`, contentSample, options.model);
+  try {
+    return JSON.parse(result.content);
+  } catch {
+    return profile.segments;
+  }
+}
+async function callProvider(provider, systemPrompt, userMessage, model) {
+  if (provider === "anthropic") {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey)
+      throw Error("ANTHROPIC_API_KEY required.");
+    const 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: model || "claude-sonnet-4-20250514",
+        max_tokens: 4096,
+        system: systemPrompt,
+        messages: [{ role: "user", content: userMessage }]
+      })
+    });
+    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
+    };
+  }
+  if (provider === "openai") {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey)
+      throw Error("OPENAI_API_KEY required.");
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: model || "gpt-4o",
+        max_tokens: 4096,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userMessage }
+        ]
+      })
+    });
+    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
+    };
+  }
+  if (provider === "ollama") {
+    const host = process.env.OLLAMA_HOST || "http://localhost:11434", response = await fetch(`${host}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: model || "llama3.2",
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userMessage }
+        ],
+        stream: !1
+      })
+    });
+    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"
+    };
+  }
+  throw Error(`Provider not supported: ${provider}`);
+}
+export const personalization = {
+  analyzeSentiment,
+  classifyText,
+  summarize,
+  recommend,
+  createProfile,
+  recordInteraction,
+  extractUserInterests
+};

package/dist/search.d.ts

@@ -0,0 +1,101 @@
+import type { AIResult } from './types';
+/**
+ * Generate embeddings for text input.
+ */
+// eslint-disable-next-line pickier/no-unused-vars
+export declare function createEmbedding(input: string, options?: EmbeddingOptions): Promise<number[]>;
+// eslint-disable-next-line pickier/no-unused-vars
+export declare function createEmbedding(input: string[], options?: EmbeddingOptions): Promise<number[][]>;
+/**
+ * Calculate cosine similarity between two vectors.
+ */
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+/**
+ * Calculate dot product similarity between two vectors.
+ */
+export declare function dotProduct(a: number[], b: number[]): number;
+/**
+ * Calculate Euclidean distance between two vectors.
+ */
+export declare function euclideanDistance(a: number[], b: number[]): number;
+/**
+ * Perform RAG: search for relevant documents and use them as context for generation.
+ */
+export declare function rag(query: string, index: VectorIndex, options?: RAGOptions): Promise<RAGResult>;
+/**
+ * Split text into overlapping chunks for embedding.
+ */
+export declare function chunkText(text: string, options?: ChunkOptions): string[];
+/**
+ * Create a searchable index from a long text by chunking and embedding.
+ */
+export declare function indexText(text: string, options?: ChunkOptions & EmbeddingOptions & { idPrefix?: string }): Promise<VectorIndex>;
+// ============================================================================
+// Exports
+// ============================================================================
+export declare const search: {
+  createEmbedding: typeof createEmbedding;
+  cosineSimilarity: typeof cosineSimilarity;
+  dotProduct: typeof dotProduct;
+  euclideanDistance: typeof euclideanDistance;
+  VectorIndex: typeof VectorIndex;
+  rag: typeof rag;
+  chunkText: typeof chunkText;
+  indexText: typeof indexText
+};
+// ============================================================================
+// Types
+// ============================================================================
+export declare interface EmbeddingOptions {
+  provider?: 'openai' | 'ollama'
+  model?: string
+}
+export declare interface SearchDocument {
+  id: string
+  content: string
+  metadata?: Record<string, unknown>
+}
+export declare interface IndexedDocument extends SearchDocument {
+  embedding: number[]
+}
+export declare interface SearchResult {
+  document: SearchDocument
+  score: number
+  rank: number
+}
+export declare interface RAGOptions {
+  provider?: 'anthropic' | 'openai' | 'ollama'
+  embeddingProvider?: 'openai' | 'ollama'
+  embeddingModel?: string
+  model?: string
+  maxTokens?: number
+  temperature?: number
+  topK?: number
+  systemPrompt?: string
+}
+export declare interface RAGResult extends AIResult {
+  sources: SearchResult[]
+}
+// ============================================================================
+// Text Chunking Utilities
+// ============================================================================
+export declare interface ChunkOptions {
+  chunkSize?: number
+  chunkOverlap?: number
+  separator?: string
+}
+/**
+ * Simple in-memory vector search index.
+ * For production, use a dedicated vector database.
+ */
+export declare class VectorIndex {
+  constructor(options?: EmbeddingOptions);
+  add(documents: SearchDocument[]): Promise<void>;
+  addWithEmbedding(document: SearchDocument, embedding: number[]): void;
+  search(query: string, topK?: number): Promise<SearchResult[]>;
+  searchByVector(queryEmbedding: number[], topK?: number): SearchResult[];
+  remove(id: string): boolean;
+  clear(): void;
+  get size(): number;
+  get ids(): string[];
+}

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.d.ts

@@ -0,0 +1,10 @@
+export declare function summarize(text: string, options?: SummarizeOptions): Promise<string>;
+export declare function ask(question: string, options?: AskOptions): Promise<string>;
+declare interface AiOptions {
+  maxTokenCount?: number
+  temperature?: number
+  topP?: number
+  modelId?: string
+}
+export declare interface SummarizeOptions extends AiOptions {}
+export declare interface AskOptions extends AiOptions {}