@snap-agent/core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1284 @@
+import {
+  MemoryStorage,
+  MongoDBStorage,
+  UpstashStorage
+} from "./chunk-Y5TTFQWC.mjs";
+
+// src/core/Agent.ts
+import { generateText, streamText } from "ai";
+
+// src/core/PluginManager.ts
+var PluginManager = class {
+  constructor(plugins = []) {
+    this.plugins = plugins.sort((a, b) => {
+      const aPriority = a.priority ?? 100;
+      const bPriority = b.priority ?? 100;
+      return aPriority - bPriority;
+    });
+  }
+  // ============================================================================
+  // Plugin Getters by Type
+  // ============================================================================
+  getRAGPlugins() {
+    return this.plugins.filter((p) => p.type === "rag");
+  }
+  getToolPlugins() {
+    return this.plugins.filter((p) => p.type === "tool");
+  }
+  getMiddlewarePlugins() {
+    return this.plugins.filter((p) => p.type === "middleware");
+  }
+  getAnalyticsPlugins() {
+    return this.plugins.filter((p) => p.type === "analytics");
+  }
+  getAllPlugins() {
+    return [...this.plugins];
+  }
+  // ============================================================================
+  // RAG Plugin Execution
+  // ============================================================================
+  /**
+   * Execute all RAG plugins and merge their contexts
+   * Returns an array of context strings, one per plugin
+   */
+  async executeRAG(message, options) {
+    const ragPlugins = this.getRAGPlugins();
+    if (ragPlugins.length === 0) {
+      return { contexts: [], allMetadata: [] };
+    }
+    const results = await Promise.all(
+      ragPlugins.map(async (plugin) => {
+        try {
+          const context = await plugin.retrieveContext(message, options);
+          const formattedContext = plugin.formatContext ? plugin.formatContext(context) : context.content;
+          return {
+            context: formattedContext,
+            metadata: context.metadata || {},
+            pluginName: plugin.name
+          };
+        } catch (error) {
+          console.error(`RAG plugin "${plugin.name}" failed:`, error);
+          return {
+            context: "",
+            metadata: { error: error instanceof Error ? error.message : "Unknown error" },
+            pluginName: plugin.name
+          };
+        }
+      })
+    );
+    return {
+      contexts: results.map((r) => r.context).filter(Boolean),
+      allMetadata: results.map((r) => ({ [r.pluginName]: r.metadata }))
+    };
+  }
+  // ============================================================================
+  // Middleware Plugin Execution
+  // ============================================================================
+  /**
+   * Execute all middleware plugins before request
+   */
+  async executeBeforeRequest(messages, context) {
+    const middlewarePlugins = this.getMiddlewarePlugins();
+    let result = { messages, metadata: {} };
+    for (const plugin of middlewarePlugins) {
+      if (plugin.beforeRequest) {
+        try {
+          const pluginResult = await plugin.beforeRequest(result.messages, context);
+          result = { ...result, ...pluginResult };
+        } catch (error) {
+          console.error(`Middleware plugin "${plugin.name}" beforeRequest failed:`, error);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Execute all middleware plugins after response
+   */
+  async executeAfterResponse(response, context) {
+    const middlewarePlugins = this.getMiddlewarePlugins();
+    let result = { response, metadata: context.metadata };
+    for (const plugin of middlewarePlugins) {
+      if (plugin.afterResponse) {
+        try {
+          const pluginResult = await plugin.afterResponse(result.response, context);
+          result = { ...result, ...pluginResult };
+        } catch (error) {
+          console.error(`Middleware plugin "${plugin.name}" afterResponse failed:`, error);
+        }
+      }
+    }
+    return result;
+  }
+  // ============================================================================
+  // Analytics Plugin Execution
+  // ============================================================================
+  /**
+   * Track request in all analytics plugins
+   */
+  async trackRequest(data) {
+    const analyticsPlugins = this.getAnalyticsPlugins();
+    await Promise.all(
+      analyticsPlugins.map(async (plugin) => {
+        try {
+          await plugin.trackRequest(data);
+        } catch (error) {
+          console.error(`Analytics plugin "${plugin.name}" trackRequest failed:`, error);
+        }
+      })
+    );
+  }
+  /**
+   * Track response in all analytics plugins
+   */
+  async trackResponse(data) {
+    const analyticsPlugins = this.getAnalyticsPlugins();
+    await Promise.all(
+      analyticsPlugins.map(async (plugin) => {
+        try {
+          await plugin.trackResponse(data);
+        } catch (error) {
+          console.error(`Analytics plugin "${plugin.name}" trackResponse failed:`, error);
+        }
+      })
+    );
+  }
+  // ============================================================================
+  // Plugin Management
+  // ============================================================================
+  /**
+   * Check if any plugins of a specific type exist
+   */
+  hasPluginsOfType(type) {
+    return this.plugins.some((p) => p.type === type);
+  }
+  /**
+   * Get plugin by name
+   */
+  getPluginByName(name) {
+    return this.plugins.find((p) => p.name === name);
+  }
+};
+
+// src/types/index.ts
+var AgentSDKError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentSDKError";
+  }
+};
+var AgentNotFoundError = class extends AgentSDKError {
+  constructor(agentId) {
+    super(`Agent not found: ${agentId}`);
+    this.name = "AgentNotFoundError";
+  }
+};
+var ThreadNotFoundError = class extends AgentSDKError {
+  constructor(threadId) {
+    super(`Thread not found: ${threadId}`);
+    this.name = "ThreadNotFoundError";
+  }
+};
+var CouldNotCreateThreadError = class extends AgentSDKError {
+  constructor(threadId) {
+    super(`Could not create thread: ${threadId}`);
+    this.name = "CouldNotCreateThreadError";
+  }
+};
+var ProviderNotFoundError = class extends AgentSDKError {
+  constructor(provider) {
+    super(`Provider not configured: ${provider}`);
+    this.name = "ProviderNotFoundError";
+  }
+};
+var InvalidConfigError = class extends AgentSDKError {
+  constructor(message) {
+    super(`Invalid configuration: ${message}`);
+    this.name = "InvalidConfigError";
+  }
+};
+
+// src/core/Agent.ts
+function extractTextContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((part) => {
+    if ("text" in part) {
+      return part.text;
+    }
+    return "";
+  }).filter(Boolean).join(" ");
+}
+var Agent = class _Agent {
+  constructor(data, storage, providerFactory) {
+    this.data = data;
+    this.storage = storage;
+    this.providerFactory = providerFactory;
+    this.pluginManager = new PluginManager(data.plugins || []);
+  }
+  /**
+   * Create a new agent
+   */
+  static async create(config, storage, providerFactory) {
+    const agentId = await storage.createAgent(config);
+    const data = await storage.getAgent(agentId);
+    if (!data) {
+      throw new AgentNotFoundError(agentId);
+    }
+    return new _Agent(data, storage, providerFactory);
+  }
+  /**
+   * Load an existing agent by ID
+   */
+  static async load(agentId, storage, providerFactory) {
+    const data = await storage.getAgent(agentId);
+    if (!data) {
+      return null;
+    }
+    return new _Agent(data, storage, providerFactory);
+  }
+  /**
+   * Update agent properties
+   */
+  async update(updates) {
+    await this.storage.updateAgent(this.data.id, updates);
+    const updatedData = await this.storage.getAgent(this.data.id);
+    if (updatedData) {
+      this.data = updatedData;
+    }
+  }
+  /**
+   * Delete this agent
+   */
+  async delete() {
+    await this.storage.deleteAgent(this.data.id);
+  }
+  /**
+   * Add files to the agent
+   */
+  async addFiles(files) {
+    const currentFiles = [...this.data.files, ...files];
+    this.data.files = currentFiles;
+    this.data.updatedAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Generate a text response with optional plugin support
+   */
+  async generateResponse(messages, options) {
+    const startTime = Date.now();
+    if (messages.length > 0) {
+      await this.pluginManager.trackRequest({
+        agentId: this.data.id,
+        threadId: options?.threadId,
+        message: extractTextContent(messages[messages.length - 1].content),
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+    const beforeResult = await this.pluginManager.executeBeforeRequest(messages, {
+      agentId: this.data.id,
+      threadId: options?.threadId
+    });
+    let systemPrompt = this.data.instructions;
+    let ragMetadata = [];
+    if (options?.useRAG && this.pluginManager.hasPluginsOfType("rag")) {
+      const lastMessage = messages[messages.length - 1];
+      const { contexts, allMetadata } = await this.pluginManager.executeRAG(
+        extractTextContent(lastMessage.content),
+        {
+          agentId: this.data.id,
+          threadId: options.threadId,
+          filters: options.ragFilters
+        }
+      );
+      if (contexts.length > 0) {
+        systemPrompt += "\n\n" + contexts.join("\n\n");
+      }
+      ragMetadata = allMetadata;
+    }
+    const model = await this.providerFactory.getModel(this.data.provider, this.data.model);
+    const { text } = await generateText({
+      model,
+      messages: beforeResult.messages,
+      system: systemPrompt
+    });
+    const afterResult = await this.pluginManager.executeAfterResponse(text, {
+      agentId: this.data.id,
+      threadId: options?.threadId,
+      metadata: beforeResult.metadata
+    });
+    const latency = Date.now() - startTime;
+    await this.pluginManager.trackResponse({
+      agentId: this.data.id,
+      threadId: options?.threadId,
+      response: afterResult.response,
+      latency,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    return {
+      text: afterResult.response,
+      metadata: {
+        ...afterResult.metadata,
+        ragMetadata,
+        latency
+      }
+    };
+  }
+  /**
+   * Stream a text response with optional plugin support
+   */
+  async streamResponse(messages, onChunk, onComplete, onError, options) {
+    try {
+      const startTime = Date.now();
+      if (messages.length > 0) {
+        await this.pluginManager.trackRequest({
+          agentId: this.data.id,
+          threadId: options?.threadId,
+          message: extractTextContent(messages[messages.length - 1].content),
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+      const beforeResult = await this.pluginManager.executeBeforeRequest(messages, {
+        agentId: this.data.id,
+        threadId: options?.threadId
+      });
+      let systemPrompt = this.data.instructions;
+      let ragMetadata = [];
+      if (options?.useRAG && this.pluginManager.hasPluginsOfType("rag")) {
+        const lastMessage = messages[messages.length - 1];
+        const { contexts, allMetadata } = await this.pluginManager.executeRAG(
+          extractTextContent(lastMessage.content),
+          {
+            agentId: this.data.id,
+            threadId: options.threadId,
+            filters: options.ragFilters
+          }
+        );
+        if (contexts.length > 0) {
+          systemPrompt += "\n\n" + contexts.join("\n\n");
+        }
+        ragMetadata = allMetadata;
+      }
+      const model = await this.providerFactory.getModel(this.data.provider, this.data.model);
+      const { textStream } = streamText({
+        model,
+        messages: beforeResult.messages,
+        system: systemPrompt
+      });
+      let fullText = "";
+      for await (const chunk of textStream) {
+        fullText += chunk;
+        onChunk(chunk);
+      }
+      const afterResult = await this.pluginManager.executeAfterResponse(fullText, {
+        agentId: this.data.id,
+        threadId: options?.threadId,
+        metadata: beforeResult.metadata
+      });
+      const latency = Date.now() - startTime;
+      await this.pluginManager.trackResponse({
+        agentId: this.data.id,
+        threadId: options?.threadId,
+        response: afterResult.response,
+        latency,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      if (onComplete) {
+        onComplete(afterResult.response, {
+          ...afterResult.metadata,
+          ragMetadata,
+          latency
+        });
+      }
+    } catch (error) {
+      if (onError) {
+        onError(error instanceof Error ? error : new Error("Unknown error"));
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Get agent ID
+   */
+  get id() {
+    return this.data.id;
+  }
+  /**
+   * Get agent name
+   */
+  get name() {
+    return this.data.name;
+  }
+  /**
+   * Get agent instructions
+   */
+  get instructions() {
+    return this.data.instructions;
+  }
+  /**
+   * Get agent provider
+   */
+  get provider() {
+    return this.data.provider;
+  }
+  /**
+   * Get agent model
+   */
+  get model() {
+    return this.data.model;
+  }
+  /**
+   * Get all plugins attached to this agent
+   */
+  get plugins() {
+    return this.data.plugins || [];
+  }
+  /**
+   * Add a plugin to this agent
+   */
+  addPlugin(plugin) {
+    this.data.plugins = [...this.data.plugins || [], plugin];
+    this.pluginManager = new PluginManager(this.data.plugins);
+    this.data.updatedAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Remove a plugin by name
+   */
+  removePlugin(pluginName) {
+    this.data.plugins = (this.data.plugins || []).filter((p) => p.name !== pluginName);
+    this.pluginManager = new PluginManager(this.data.plugins);
+    this.data.updatedAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Get all agent data
+   */
+  toJSON() {
+    return { ...this.data };
+  }
+  /**
+   * Ingest documents into RAG plugins
+   * Documents will be ingested into all RAG plugins that support ingestion
+   */
+  async ingestDocuments(documents, options) {
+    const ragPlugins = this.data.plugins?.filter((p) => p.type === "rag") || [];
+    const results = [];
+    for (const plugin of ragPlugins) {
+      if ("ingest" in plugin && typeof plugin.ingest === "function") {
+        const result = await plugin.ingest(documents, {
+          agentId: this.data.id,
+          ...options
+        });
+        results.push(result);
+      }
+    }
+    if (results.length === 0) {
+      throw new Error("No RAG plugins with ingestion support found");
+    }
+    return results;
+  }
+  /**
+   * Update a document in RAG plugins
+   */
+  async updateDocument(id, document, options) {
+    const ragPlugins = this.data.plugins?.filter((p) => p.type === "rag") || [];
+    let updated = false;
+    for (const plugin of ragPlugins) {
+      if ("update" in plugin && typeof plugin.update === "function") {
+        await plugin.update(id, document, {
+          agentId: this.data.id,
+          ...options
+        });
+        updated = true;
+      }
+    }
+    if (!updated) {
+      throw new Error("No RAG plugins with update support found");
+    }
+  }
+  /**
+   * Delete documents from RAG plugins
+   */
+  async deleteDocuments(ids, options) {
+    const ragPlugins = this.data.plugins?.filter((p) => p.type === "rag") || [];
+    let totalDeleted = 0;
+    for (const plugin of ragPlugins) {
+      if ("delete" in plugin && typeof plugin.delete === "function") {
+        const count = await plugin.delete(ids, {
+          agentId: this.data.id,
+          ...options
+        });
+        totalDeleted += count;
+      }
+    }
+    return totalDeleted;
+  }
+  /**
+   * Perform bulk operations on RAG plugins
+   */
+  async bulkDocumentOperations(operations, options) {
+    const ragPlugins = this.data.plugins?.filter((p) => p.type === "rag") || [];
+    const results = [];
+    for (const plugin of ragPlugins) {
+      if ("bulk" in plugin && typeof plugin.bulk === "function") {
+        const result = await plugin.bulk(operations, {
+          agentId: this.data.id,
+          ...options
+        });
+        results.push(result);
+      }
+    }
+    if (results.length === 0) {
+      throw new Error("No RAG plugins with bulk operation support found");
+    }
+    return results;
+  }
+  /**
+   * Ingest documents from a URL source (CSV, JSON, XML, API)
+   * Supports authentication, scheduling, and data transformation
+   */
+  async ingestFromUrl(source, options) {
+    const ragPlugins = this.data.plugins?.filter((p) => p.type === "rag") || [];
+    const results = [];
+    for (const plugin of ragPlugins) {
+      if ("ingestFromUrl" in plugin && typeof plugin.ingestFromUrl === "function") {
+        const result = await plugin.ingestFromUrl(source, {
+          agentId: this.data.id,
+          ...options
+        });
+        results.push(result);
+      }
+    }
+    if (results.length === 0) {
+      throw new Error("No RAG plugins with URL ingestion support found");
+    }
+    return results;
+  }
+  /**
+   * Handle webhook payload for real-time document updates
+   * Useful for product inventory updates, price changes, etc.
+   */
+  async handleWebhook(payload, source, options) {
+    const ragPlugins = this.data.plugins?.filter((p) => p.type === "rag") || [];
+    const results = [];
+    for (const plugin of ragPlugins) {
+      if ("handleWebhook" in plugin && typeof plugin.handleWebhook === "function") {
+        const result = await plugin.handleWebhook(payload, source, {
+          agentId: this.data.id,
+          ...options
+        });
+        results.push(result);
+      }
+    }
+    if (results.length === 0) {
+      throw new Error("No RAG plugins with webhook support found");
+    }
+    return results;
+  }
+};
+
+// src/core/Thread.ts
+var Thread = class _Thread {
+  constructor(data, storage) {
+    this.data = data;
+    this.storage = storage;
+  }
+  /**
+   * Create a new thread
+   */
+  static async create(config, storage) {
+    const threadId = await storage.createThread(config);
+    const data = await storage.getThread(threadId);
+    if (!data) {
+      throw new CouldNotCreateThreadError(threadId);
+    }
+    return new _Thread(data, storage);
+  }
+  /**
+   * Load an existing thread by ID
+   */
+  static async load(threadId, storage) {
+    const data = await storage.getThread(threadId);
+    if (!data) {
+      return null;
+    }
+    return new _Thread(data, storage);
+  }
+  /**
+   * Update thread properties
+   */
+  async update(updates) {
+    await this.storage.updateThread(this.data.id, updates);
+    const updatedData = await this.storage.getThread(this.data.id);
+    if (updatedData) {
+      this.data = updatedData;
+    }
+  }
+  /**
+   * Delete this thread
+   */
+  async delete() {
+    await this.storage.deleteThread(this.data.id);
+  }
+  /**
+   * Add a message to the thread
+   */
+  async addMessage(role, content, attachments) {
+    const messageId = await this.storage.addMessage(
+      this.data.id,
+      role,
+      content,
+      attachments
+    );
+    const updatedData = await this.storage.getThread(this.data.id);
+    if (updatedData) {
+      this.data = updatedData;
+    }
+    return messageId;
+  }
+  /**
+   * Get messages from this thread
+   */
+  async getMessages(limit) {
+    return await this.storage.getMessages(this.data.id, limit);
+  }
+  /**
+   * Get conversation context for AI (formatted for Vercel AI SDK)
+   */
+  async getConversationContext(maxMessages = 20) {
+    const messages = await this.storage.getMessages(this.data.id, maxMessages);
+    return messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content
+    }));
+  }
+  /**
+   * Update thread name
+   */
+  async updateName(name) {
+    await this.update({ name });
+  }
+  /**
+   * Update pending status
+   */
+  async updatePendingStatus(isPending) {
+    this.data.isPendingThread = isPending;
+    this.data.updatedAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Get thread ID
+   */
+  get id() {
+    return this.data.id;
+  }
+  /**
+   * Get thread name
+   */
+  get name() {
+    return this.data.name;
+  }
+  /**
+   * Get agent ID
+   */
+  get agentId() {
+    return this.data.agentId;
+  }
+  /**
+   * Get messages (cached from last load)
+   */
+  get messages() {
+    return this.data.messages;
+  }
+  /**
+   * Check if thread is pending
+   */
+  get isPending() {
+    return this.data.isPendingThread;
+  }
+  /**
+   * Get all thread data
+   */
+  toJSON() {
+    return { ...this.data };
+  }
+};
+
+// src/providers/index.ts
+import { createOpenAI } from "@ai-sdk/openai";
+var ProviderFactory = class {
+  constructor(config) {
+    this.modelCache = /* @__PURE__ */ new Map();
+    this.config = config;
+  }
+  /**
+   * Get a language model for the specified provider and model
+   * Uses dynamic imports for edge runtime compatibility
+   */
+  async getModel(provider, modelName) {
+    const cacheKey = `${provider}:${modelName}`;
+    if (this.modelCache.has(cacheKey)) {
+      return this.modelCache.get(cacheKey);
+    }
+    let model;
+    switch (provider) {
+      case "openai": {
+        if (!this.config.openai?.apiKey) {
+          throw new ProviderNotFoundError("OpenAI API key not configured");
+        }
+        const openai = createOpenAI({
+          apiKey: this.config.openai.apiKey
+        });
+        model = openai(modelName);
+        break;
+      }
+      case "anthropic": {
+        if (!this.config.anthropic?.apiKey) {
+          throw new ProviderNotFoundError("Anthropic API key not configured");
+        }
+        try {
+          const { createAnthropic } = await import("./dist-JU54Y3G4.mjs");
+          const anthropic = createAnthropic({
+            apiKey: this.config.anthropic.apiKey
+          });
+          model = anthropic(modelName);
+        } catch (error) {
+          throw new ProviderNotFoundError(
+            "Anthropic provider not installed. Run: npm install @ai-sdk/anthropic"
+          );
+        }
+        break;
+      }
+      case "google": {
+        if (!this.config.google?.apiKey) {
+          throw new ProviderNotFoundError("Google API key not configured");
+        }
+        try {
+          const { createGoogleGenerativeAI } = await import("./dist-2CMI4QQD.mjs");
+          const google = createGoogleGenerativeAI({
+            apiKey: this.config.google.apiKey
+          });
+          model = google(modelName);
+        } catch (error) {
+          throw new ProviderNotFoundError(
+            "Google provider not installed. Run: npm install @ai-sdk/google"
+          );
+        }
+        break;
+      }
+      default:
+        throw new ProviderNotFoundError(`Unknown provider: ${provider}`);
+    }
+    this.modelCache.set(cacheKey, model);
+    return model;
+  }
+  /**
+   * Check if a provider is configured
+   */
+  isProviderConfigured(provider) {
+    switch (provider) {
+      case "openai":
+        return !!this.config.openai?.apiKey;
+      case "anthropic":
+        return !!this.config.anthropic?.apiKey;
+      case "google":
+        return !!this.config.google?.apiKey;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Get list of configured providers
+   */
+  getConfiguredProviders() {
+    const providers = [];
+    if (this.config.openai?.apiKey) providers.push("openai");
+    if (this.config.anthropic?.apiKey) providers.push("anthropic");
+    if (this.config.google?.apiKey) providers.push("google");
+    return providers;
+  }
+  /**
+   * Clear the model cache
+   */
+  clearCache() {
+    this.modelCache.clear();
+  }
+};
+var Models = {
+  OpenAI: {
+    GPT4O: "gpt-4o",
+    GPT4O_MINI: "gpt-4o-mini",
+    GPT4_TURBO: "gpt-4-turbo",
+    GPT35_TURBO: "gpt-3.5-turbo"
+  },
+  Anthropic: {
+    CLAUDE_35_SONNET: "claude-3-5-sonnet-20241022",
+    CLAUDE_35_HAIKU: "claude-3-5-haiku-20241022",
+    CLAUDE_3_OPUS: "claude-3-opus-20240229"
+  },
+  Google: {
+    GEMINI_2_FLASH: "gemini-2.0-flash-exp",
+    GEMINI_15_PRO: "gemini-1.5-pro",
+    GEMINI_15_FLASH: "gemini-1.5-flash"
+  }
+};
+
+// src/inc/DefaultRAGPlugin.ts
+var DefaultRAGPlugin = class {
+  constructor(config) {
+    this.name = "default-rag";
+    this.type = "rag";
+    this.documents = /* @__PURE__ */ new Map();
+    this.config = {
+      embeddingProvider: config.embeddingProvider || "openai",
+      embeddingModel: config.embeddingModel || "text-embedding-3-small",
+      limit: config.limit || 5,
+      embeddingProviderApiKey: config.embeddingProviderApiKey
+    };
+  }
+  /**
+   * Retrieve context for a message using semantic search
+   */
+  async retrieveContext(message, options) {
+    const agentDocs = this.documents.get(options.agentId) || [];
+    if (agentDocs.length === 0) {
+      return {
+        content: "",
+        sources: [],
+        metadata: { count: 0 }
+      };
+    }
+    const queryEmbedding = await this.generateEmbedding(message);
+    const scoredDocs = agentDocs.map((doc) => ({
+      ...doc,
+      score: this.cosineSimilarity(queryEmbedding, doc.embedding)
+    })).sort((a, b) => b.score - a.score).slice(0, this.config.limit);
+    const content = scoredDocs.map((doc, idx) => `[${idx + 1}] ${doc.content}`).join("\n\n");
+    return {
+      content,
+      sources: scoredDocs.map((doc) => ({
+        id: doc.id,
+        title: doc.metadata?.title,
+        score: doc.score,
+        type: "document",
+        ...doc.metadata
+      })),
+      metadata: {
+        count: scoredDocs.length,
+        totalDocuments: agentDocs.length
+      }
+    };
+  }
+  /**
+   * Ingest documents into the RAG system
+   */
+  async ingest(documents, options) {
+    if (!options?.agentId) {
+      return {
+        success: false,
+        indexed: 0,
+        failed: documents.length,
+        errors: [
+          {
+            id: "batch",
+            error: "agentId is required for document ingestion"
+          }
+        ]
+      };
+    }
+    let indexed = 0;
+    const errors = [];
+    const agentDocs = this.documents.get(options.agentId) || [];
+    for (const doc of documents) {
+      try {
+        const embedding = await this.generateEmbedding(doc.content);
+        const existingIdx = agentDocs.findIndex((d) => d.id === doc.id);
+        const storedDoc = {
+          ...doc,
+          embedding,
+          agentId: options.agentId,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        if (existingIdx >= 0) {
+          if (options.overwrite) {
+            agentDocs[existingIdx] = storedDoc;
+            indexed++;
+          } else if (!options.skipExisting) {
+            agentDocs[existingIdx] = storedDoc;
+            indexed++;
+          }
+        } else {
+          agentDocs.push(storedDoc);
+          indexed++;
+        }
+      } catch (error) {
+        errors.push({
+          id: doc.id,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    }
+    this.documents.set(options.agentId, agentDocs);
+    return {
+      success: errors.length === 0,
+      indexed,
+      failed: errors.length,
+      errors: errors.length > 0 ? errors : void 0,
+      metadata: {
+        totalDocuments: agentDocs.length
+      }
+    };
+  }
+  /**
+   * Update a single document
+   */
+  async update(id, document, options) {
+    if (!options?.agentId) {
+      throw new Error("agentId is required for document update");
+    }
+    const agentDocs = this.documents.get(options.agentId) || [];
+    const existingIdx = agentDocs.findIndex((d) => d.id === id);
+    if (existingIdx < 0) {
+      throw new Error(`Document not found: ${id}`);
+    }
+    const existing = agentDocs[existingIdx];
+    if (document.content && document.content !== existing.content) {
+      const embedding = await this.generateEmbedding(document.content);
+      agentDocs[existingIdx] = {
+        ...existing,
+        ...document,
+        content: document.content,
+        embedding
+      };
+    } else {
+      agentDocs[existingIdx] = {
+        ...existing,
+        ...document,
+        id: existing.id,
+        // Ensure ID doesn't change
+        content: existing.content,
+        // Ensure content doesn't change
+        embedding: existing.embedding
+        // Keep existing embedding
+      };
+    }
+    this.documents.set(options.agentId, agentDocs);
+  }
+  /**
+   * Delete document(s) by ID
+   */
+  async delete(ids, options) {
+    if (!options?.agentId) {
+      throw new Error("agentId is required for document deletion");
+    }
+    const agentDocs = this.documents.get(options.agentId) || [];
+    const idsArray = Array.isArray(ids) ? ids : [ids];
+    const initialCount = agentDocs.length;
+    const filtered = agentDocs.filter((doc) => !idsArray.includes(doc.id));
+    const deletedCount = initialCount - filtered.length;
+    this.documents.set(options.agentId, filtered);
+    return deletedCount;
+  }
+  /**
+   * Generate embedding using OpenAI
+   */
+  async generateEmbedding(text) {
+    const response = await fetch("https://api.openai.com/v1/embeddings", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.config.embeddingProviderApiKey}`
+      },
+      body: JSON.stringify({
+        model: this.config.embeddingModel,
+        input: text
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    return data.data[0].embedding;
+  }
+  /**
+   * Calculate cosine similarity between two vectors
+   */
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+      throw new Error("Vectors must have the same length");
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    normA = Math.sqrt(normA);
+    normB = Math.sqrt(normB);
+    if (normA === 0 || normB === 0) {
+      return 0;
+    }
+    return dotProduct / (normA * normB);
+  }
+  /**
+   * Get statistics about stored documents
+   */
+  getStats() {
+    const stats = {
+      totalAgents: this.documents.size,
+      agentStats: {}
+    };
+    for (const [agentId, docs] of this.documents.entries()) {
+      stats.agentStats[agentId] = {
+        documentCount: docs.length
+      };
+    }
+    return stats;
+  }
+  /**
+   * Clear all documents for an agent
+   */
+  clearAgent(agentId) {
+    this.documents.delete(agentId);
+  }
+  /**
+   * Clear all documents
+   */
+  clearAll() {
+    this.documents.clear();
+  }
+};
+
+// src/core/Client.ts
+var AgentClient = class {
+  constructor(config) {
+    this.validateConfig(config);
+    this.storage = config.storage;
+    this.providers = config.providers;
+    this.providerFactory = new ProviderFactory(config.providers);
+  }
+  validateConfig(config) {
+    if (!config.storage) {
+      throw new InvalidConfigError("Storage adapter is required");
+    }
+    if (!config.providers || Object.keys(config.providers).length === 0) {
+      throw new InvalidConfigError("At least one provider must be configured");
+    }
+  }
+  // ============================================================================
+  // Agent Operations
+  // ============================================================================
+  /**
+   * Create a new agent
+   */
+  async createAgent(config) {
+    const agentConfig = {
+      ...config,
+      provider: config.provider || "openai"
+    };
+    if (agentConfig.rag?.enabled) {
+      const hasRAGPlugin = agentConfig.plugins?.some((p) => p.type === "rag");
+      if (!hasRAGPlugin) {
+        const embeddingProviderApiKey = agentConfig.rag.embeddingProviderApiKey || this.providers.openai?.apiKey;
+        if (!embeddingProviderApiKey) {
+          throw new InvalidConfigError(
+            "RAG requires an embedding provider API key. Either configure OpenAI provider or set rag.embeddingProviderApiKey"
+          );
+        }
+        const defaultRAGPlugin = new DefaultRAGPlugin({
+          embeddingProviderApiKey,
+          embeddingProvider: agentConfig.rag.embeddingProvider,
+          embeddingModel: agentConfig.rag.embeddingModel,
+          limit: agentConfig.rag.limit
+        });
+        agentConfig.plugins = [...agentConfig.plugins || [], defaultRAGPlugin];
+      }
+    }
+    return await Agent.create(agentConfig, this.storage, this.providerFactory);
+  }
+  /**
+   * Get an agent by ID
+   */
+  async getAgent(agentId) {
+    const agent = await Agent.load(agentId, this.storage, this.providerFactory);
+    if (!agent) {
+      throw new AgentNotFoundError(agentId);
+    }
+    return agent;
+  }
+  /**
+   * List agents for a user
+   */
+  async listAgents(userId, organizationId) {
+    return await this.storage.listAgents(userId, organizationId);
+  }
+  /**
+   * Delete an agent
+   */
+  async deleteAgent(agentId) {
+    const agent = await this.getAgent(agentId);
+    await agent.delete();
+  }
+  // ============================================================================
+  // Thread Operations
+  // ============================================================================
+  /**
+   * Create a new thread
+   */
+  async createThread(config) {
+    await this.getAgent(config.agentId);
+    return await Thread.create(config, this.storage);
+  }
+  /**
+   * Get a thread by ID
+   */
+  async getThread(threadId) {
+    if (!threadId) {
+      throw new ThreadNotFoundError("Thread ID is required");
+    }
+    const thread = await Thread.load(threadId, this.storage);
+    if (!thread) {
+      throw new ThreadNotFoundError(threadId);
+    }
+    return thread;
+  }
+  /**
+   * List threads by user or agent
+   */
+  async listThreads(filters) {
+    return await this.storage.listThreads(filters);
+  }
+  /**
+   * Delete a thread
+   */
+  async deleteThread(threadId) {
+    const thread = await this.getThread(threadId);
+    await thread.delete();
+  }
+  // ============================================================================
+  // Chat Operations
+  // ============================================================================
+  /**
+   * Send a message and get a response (non-streaming)
+   */
+  async chat(request) {
+    const thread = await this.getThread(request.threadId);
+    const agent = await this.getAgent(thread.agentId);
+    await thread.addMessage("user", request.message, request.attachments);
+    const contextLength = request.contextLength ?? 20;
+    const messages = await thread.getConversationContext(contextLength);
+    const result = await agent.generateResponse(messages, {
+      useRAG: request.useRAG,
+      ragFilters: request.ragFilters,
+      threadId: thread.id
+    });
+    const messageId = await thread.addMessage("assistant", result.text);
+    return {
+      reply: result.text,
+      messageId,
+      threadId: thread.id,
+      timestamp: /* @__PURE__ */ new Date(),
+      metadata: result.metadata
+    };
+  }
+  /**
+   * Send a message and stream the response
+   */
+  async chatStream(request, callbacks) {
+    try {
+      const thread = await this.getThread(request.threadId);
+      const agent = await this.getAgent(thread.agentId);
+      await thread.addMessage("user", request.message, request.attachments);
+      const contextLength = request.contextLength ?? 20;
+      const messages = await thread.getConversationContext(contextLength);
+      await agent.streamResponse(
+        messages,
+        callbacks.onChunk,
+        async (fullResponse, metadata) => {
+          await thread.addMessage("assistant", fullResponse);
+          callbacks.onComplete(fullResponse, metadata);
+        },
+        callbacks.onError,
+        {
+          useRAG: request.useRAG,
+          ragFilters: request.ragFilters,
+          threadId: thread.id
+        }
+      );
+    } catch (error) {
+      callbacks.onError(
+        error instanceof Error ? error : new Error("Unknown error")
+      );
+    }
+  }
+  /**
+   * Generate a name for a thread based on its first message
+   */
+  async generateThreadName(firstMessage) {
+    const providers = this.providerFactory.getConfiguredProviders();
+    if (providers.length === 0) {
+      throw new InvalidConfigError("No providers configured");
+    }
+    const model = await this.providerFactory.getModel(providers[0], "gpt-4o");
+    const { generateText: generateText2 } = await import("ai");
+    const { text } = await generateText2({
+      model,
+      messages: [
+        {
+          role: "user",
+          content: `Generate a brief and clear title to identify this conversation thread, based solely on the following first user message:
+"${firstMessage}"
+
+Requirements:
+- Maximum 4 words
+- Specific and concise
+- Avoid generic words like "query" or "question"
+- Reflect the main topic
+Return only the title without additional explanations.`
+        }
+      ],
+      temperature: 0.3
+    });
+    return text.trim() || "New Chat";
+  }
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+  /**
+   * Get list of configured providers
+   */
+  getConfiguredProviders() {
+    return this.providerFactory.getConfiguredProviders();
+  }
+  /**
+   * Check if a provider is configured
+   */
+  isProviderConfigured(provider) {
+    return this.providerFactory.isProviderConfigured(provider);
+  }
+};
+
+// src/index.ts
+function createClient(config) {
+  return new AgentClient(config);
+}
+export {
+  Agent,
+  AgentClient,
+  AgentNotFoundError,
+  AgentSDKError,
+  DefaultRAGPlugin,
+  InvalidConfigError,
+  MemoryStorage,
+  Models,
+  MongoDBStorage,
+  PluginManager,
+  ProviderFactory,
+  ProviderNotFoundError,
+  Thread,
+  ThreadNotFoundError,
+  UpstashStorage,
+  createClient
+};