@stacksjs/ai 0.70.87 → 0.70.90

package/dist/mcp.js

@@ -0,0 +1,361 @@
+export class MCPClient {
+  config;
+  process = null;
+  requestId = 0;
+  pendingRequests = new Map;
+  tools = [];
+  resources = [];
+  prompts = [];
+  initialized = !1;
+  buffer = "";
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    if (this.config.transport.type === "stdio")
+      await this.connectStdio();
+    else if (this.config.transport.type === "sse" || this.config.transport.type === "streamable-http")
+      await this.connectHTTP();
+    else
+      throw Error(`Unsupported transport type: ${this.config.transport.type}`);
+    this.initialized = !0;
+  }
+  async connectStdio() {
+    const transport = this.config.transport, { spawn } = await import("bun");
+    this.process = spawn([transport.command, ...transport.args || []], {
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env, ...transport.env }
+    });
+    this.readStdout();
+    await this.sendRequest("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "stacks-ai", version: "1.0.0" }
+    });
+    await this.sendNotification("notifications/initialized", {});
+    await this.discoverCapabilities();
+  }
+  async connectHTTP() {
+    const transport = this.config.transport, response = await fetch(transport.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...transport.headers
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: this.nextId(),
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "stacks-ai", version: "1.0.0" }
+        }
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw Error(`MCP HTTP connection error: ${error}`);
+    }
+    await this.discoverCapabilities();
+  }
+  async readStdout() {
+    if (!this.process)
+      return;
+    const reader = this.process.stdout?.getReader();
+    if (!reader)
+      return;
+    const decoder = new TextDecoder;
+    try {
+      while (!0) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        this.buffer += decoder.decode(value, { stream: !0 });
+        this.processBuffer();
+      }
+    } catch {}
+  }
+  processBuffer() {
+    const lines = this.buffer.split(`
+`);
+    this.buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      try {
+        const message = JSON.parse(line);
+        if (message.id !== void 0 && this.pendingRequests.has(message.id)) {
+          const pending = this.pendingRequests.get(message.id);
+          this.pendingRequests.delete(message.id);
+          if (message.error)
+            pending.reject(Error(message.error.message || "MCP error"));
+          else
+            pending.resolve(message.result);
+        }
+      } catch {}
+    }
+  }
+  nextId() {
+    return ++this.requestId;
+  }
+  async sendRequest(method, params = {}) {
+    const id = this.nextId(), message = JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    }) + `
+`;
+    if (this.config.transport.type === "stdio" && this.process) {
+      const writer = this.process.stdin?.getWriter();
+      if (writer) {
+        await writer.write(new TextEncoder().encode(message));
+        writer.releaseLock();
+      }
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          this.pendingRequests.delete(id);
+          reject(Error(`MCP request timeout: ${method}`));
+        }, 30000);
+        this.pendingRequests.set(id, {
+          resolve: (value) => {
+            clearTimeout(timeout);
+            resolve(value);
+          },
+          reject: (error) => {
+            clearTimeout(timeout);
+            reject(error);
+          }
+        });
+      });
+    }
+    if (this.config.transport.type === "sse" || this.config.transport.type === "streamable-http") {
+      const transport = this.config.transport, response = await fetch(transport.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...transport.headers
+        },
+        body: message
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw Error(`MCP request error: ${error}`);
+      }
+      const result = await response.json();
+      if (result.error)
+        throw Error(result.error.message || "MCP error");
+      return result.result;
+    }
+    throw Error("No transport available");
+  }
+  async sendNotification(method, params = {}) {
+    const message = JSON.stringify({
+      jsonrpc: "2.0",
+      method,
+      params
+    }) + `
+`;
+    if (this.config.transport.type === "stdio" && this.process) {
+      const writer = this.process.stdin?.getWriter();
+      if (writer) {
+        await writer.write(new TextEncoder().encode(message));
+        writer.releaseLock();
+      }
+    }
+  }
+  async discoverCapabilities() {
+    const capabilities = this.config.capabilities || { tools: !0, resources: !0, prompts: !0 };
+    if (capabilities.tools !== !1)
+      try {
+        const result = await this.sendRequest("tools/list");
+        this.tools = result?.tools || [];
+      } catch {
+        this.tools = [];
+      }
+    if (capabilities.resources !== !1)
+      try {
+        const result = await this.sendRequest("resources/list");
+        this.resources = result?.resources || [];
+      } catch {
+        this.resources = [];
+      }
+    if (capabilities.prompts !== !1)
+      try {
+        const result = await this.sendRequest("prompts/list");
+        this.prompts = result?.prompts || [];
+      } catch {
+        this.prompts = [];
+      }
+  }
+  listTools() {
+    return this.tools;
+  }
+  listResources() {
+    return this.resources;
+  }
+  listPrompts() {
+    return this.prompts;
+  }
+  async callTool(name, args = {}) {
+    if (!this.initialized)
+      throw Error("MCP client not connected. Call connect() first.");
+    return await this.sendRequest("tools/call", { name, arguments: args });
+  }
+  async readResource(uri) {
+    if (!this.initialized)
+      throw Error("MCP client not connected. Call connect() first.");
+    const contents = (await this.sendRequest("resources/read", { uri }))?.contents?.[0];
+    return {
+      uri: contents?.uri || uri,
+      mimeType: contents?.mimeType,
+      text: contents?.text,
+      blob: contents?.blob
+    };
+  }
+  async getPrompt(name, args = {}) {
+    if (!this.initialized)
+      throw Error("MCP client not connected. Call connect() first.");
+    return this.sendRequest("prompts/get", { name, arguments: args });
+  }
+  toAnthropicTools() {
+    return this.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.inputSchema
+    }));
+  }
+  toOpenAITools() {
+    return this.tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema
+      }
+    }));
+  }
+  async disconnect() {
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+    for (const pending of this.pendingRequests.values())
+      try {
+        pending.reject(Error("MCP client disconnected"));
+      } catch {}
+    this.pendingRequests.clear();
+    this.initialized = !1;
+    this.tools = [];
+    this.resources = [];
+    this.prompts = [];
+  }
+  get isConnected() {
+    return this.initialized;
+  }
+  get serverName() {
+    return this.config.name;
+  }
+}
+
+export class MCPManager {
+  clients = new Map;
+  async addServer(config) {
+    if (this.clients.has(config.name))
+      throw Error(`MCP server already registered: ${config.name}`);
+    const client = new MCPClient(config);
+    await client.connect();
+    this.clients.set(config.name, client);
+    return client;
+  }
+  async removeServer(name) {
+    const client = this.clients.get(name);
+    if (client) {
+      await client.disconnect();
+      this.clients.delete(name);
+    }
+  }
+  getServer(name) {
+    return this.clients.get(name);
+  }
+  listServers() {
+    return Array.from(this.clients.keys());
+  }
+  getAllTools() {
+    const allTools = [];
+    for (const [name, client] of this.clients)
+      for (const tool of client.listTools())
+        allTools.push({ ...tool, serverName: name });
+    return allTools;
+  }
+  async callTool(toolPath, args = {}) {
+    if (toolPath.includes("/")) {
+      const [serverName, toolName] = toolPath.split("/", 2);
+      if (!serverName || !toolName)
+        throw Error(`Invalid MCP tool path: ${toolPath}`);
+      const client = this.clients.get(serverName);
+      if (!client)
+        throw Error(`MCP server not found: ${serverName}`);
+      return client.callTool(toolName, args);
+    }
+    for (const [, client] of this.clients)
+      if (client.listTools().some((t) => t.name === toolPath))
+        return client.callTool(toolPath, args);
+    throw Error(`MCP tool not found: ${toolPath}`);
+  }
+  toAnthropicTools() {
+    const tools = [];
+    for (const [serverName, client] of this.clients)
+      for (const tool of client.listTools())
+        tools.push({
+          name: `${serverName}__${tool.name}`,
+          description: `[${serverName}] ${tool.description}`,
+          input_schema: tool.inputSchema
+        });
+    return tools;
+  }
+  toOpenAITools() {
+    const tools = [];
+    for (const [serverName, client] of this.clients)
+      for (const tool of client.listTools())
+        tools.push({
+          type: "function",
+          function: {
+            name: `${serverName}__${tool.name}`,
+            description: `[${serverName}] ${tool.description}`,
+            parameters: tool.inputSchema
+          }
+        });
+    return tools;
+  }
+  async disconnectAll() {
+    const disconnects = Array.from(this.clients.values()).map((c) => c.disconnect());
+    await Promise.all(disconnects);
+    this.clients.clear();
+  }
+}
+export async function connectStdio(name, command, args, env) {
+  const client = new MCPClient({
+    name,
+    transport: { type: "stdio", command, args, env }
+  });
+  await client.connect();
+  return client;
+}
+export async function connectHTTP(name, url, headers) {
+  const client = new MCPClient({
+    name,
+    transport: { type: "streamable-http", url, headers }
+  });
+  await client.connect();
+  return client;
+}
+export const mcp = {
+  MCPClient,
+  MCPManager,
+  connectStdio,
+  connectHTTP
+};

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
+};