@stacksjs/ai 0.70.88 → 0.70.91

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

@@ -0,0 +1,118 @@
+/**
+ * Analyze the sentiment of text using AI.
+ */
+export declare function analyzeSentiment(text: string, options?: {
+    provider?: 'anthropic' | 'openai' | 'ollama'
+    model?: string
+    aspects?: string[]
+  }): Promise<SentimentResult>;
+/**
+ * Classify text into one of the provided labels.
+ */
+export declare function classifyText(text: string, labels: string[], options?: {
+    provider?: 'anthropic' | 'openai' | 'ollama'
+    model?: string
+    multiLabel?: boolean
+  }): Promise<ClassificationResult>;
+/**
+ * Generate an intelligent summary of text.
+ *
+ * Not exported as a bare top-level identifier because `text.ts` already
+ * exposes `summarize`, and `index.ts` re-exports both via `export *`.
+ * Reach this multi-provider variant through the `personalization`
+ * namespace export below: `personalization.summarize(...)`.
+ */
+declare function summarize(text: string, options?: SummaryOptions): Promise<AIResult>;
+/**
+ * Generate personalized content recommendations based on user profile and available items.
+ */
+export declare function recommend(profile: UserProfile, items: ContentItem[], options?: RecommendationOptions): Promise<RecommendationResult>;
+/**
+ * Create a new empty user profile.
+ */
+export declare function createProfile(id: string, segments?: string[]): UserProfile;
+/**
+ * Record a user interaction and update preferences.
+ */
+export declare function recordInteraction(profile: UserProfile, interaction: Interaction): UserProfile;
+/**
+ * Extract keywords/topics from user interactions using AI.
+ */
+export declare function extractUserInterests(profile: UserProfile, items: ContentItem[], options?: { provider?: 'anthropic' | 'openai' | 'ollama'; model?: string }): Promise<string[]>;
+// ============================================================================
+// Exports
+// ============================================================================
+export declare const personalization: {
+  analyzeSentiment: typeof analyzeSentiment;
+  classifyText: typeof classifyText;
+  summarize: typeof summarize;
+  recommend: typeof recommend;
+  createProfile: typeof createProfile;
+  recordInteraction: typeof recordInteraction;
+  extractUserInterests: typeof extractUserInterests
+};
+// ============================================================================
+// Types
+// ============================================================================
+export declare interface UserProfile {
+  id: string
+  preferences: Record<string, number>
+  interactions: Interaction[]
+  segments: string[]
+  metadata?: Record<string, unknown>
+}
+export declare interface Interaction {
+  type: 'view' | 'click' | 'purchase' | 'like' | 'dislike' | 'share' | 'bookmark' | 'custom'
+  itemId: string
+  timestamp: number
+  weight?: number
+  metadata?: Record<string, unknown>
+}
+export declare interface ContentItem {
+  id: string
+  content: string
+  category?: string
+  tags?: string[]
+  metadata?: Record<string, unknown>
+}
+export declare interface RecommendationOptions {
+  provider?: 'anthropic' | 'openai' | 'ollama'
+  model?: string
+  maxTokens?: number
+  temperature?: number
+  limit?: number
+}
+export declare interface RecommendationResult {
+  recommendations: Array<{
+    itemId: string
+    score: number
+    reason: string
+  }>
+  model: string
+  provider: string
+}
+export declare interface SentimentResult {
+  sentiment: 'positive' | 'negative' | 'neutral' | 'mixed'
+  score: number
+  confidence: number
+  aspects?: Array<{
+    aspect: string
+    sentiment: 'positive' | 'negative' | 'neutral'
+    score: number
+  }>
+}
+export declare interface ClassificationResult {
+  label: string
+  confidence: number
+  allLabels: Array<{
+    label: string
+    confidence: number
+  }>
+}
+export declare interface SummaryOptions {
+  provider?: 'anthropic' | 'openai' | 'ollama'
+  model?: string
+  maxLength?: number
+  style?: 'concise' | 'detailed' | 'bullet-points'
+  language?: string
+}