@nebutra/agents 1.0.0 → 1.1.1

package/dist/chunk-RDOFKRI6.js

@@ -0,0 +1,166 @@
+// src/memory.ts
+import { logger } from "@nebutra/logger";
+var DEFAULT_TTL_SECONDS = 7 * 24 * 60 * 60;
+function getTtl() {
+  const envTtl = process.env.AGENT_MEMORY_TTL_SECONDS;
+  if (envTtl) {
+    const parsed = Number.parseInt(envTtl, 10);
+    if (!Number.isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return DEFAULT_TTL_SECONDS;
+}
+function memoryKey(tenantId, conversationId) {
+  return `agent:memory:${tenantId}:${conversationId}`;
+}
+async function tryGetRedis() {
+  try {
+    const { getRedis } = await import("@nebutra/cache");
+    return getRedis();
+  } catch {
+    return null;
+  }
+}
+async function getMemory(tenantId, conversationId) {
+  const redis = await tryGetRedis();
+  if (!redis) return [];
+  try {
+    const raw = await redis.get(memoryKey(tenantId, conversationId));
+    if (!raw) return [];
+    const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+    if (!Array.isArray(parsed)) return [];
+    return parsed.map((m) => {
+      const toolCalls = m.toolCalls;
+      if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+        return {
+          role: m.role,
+          content: String(m.content ?? ""),
+          toolCalls,
+          timestamp: new Date(String(m.timestamp))
+        };
+      }
+      return {
+        role: m.role,
+        content: String(m.content ?? ""),
+        timestamp: new Date(String(m.timestamp))
+      };
+    });
+  } catch (error) {
+    logger.warn("Failed to load agent memory, falling back to empty", {
+      tenantId,
+      conversationId,
+      error
+    });
+    return [];
+  }
+}
+async function saveMemory(tenantId, conversationId, messages) {
+  const redis = await tryGetRedis();
+  if (!redis) return;
+  try {
+    const key = memoryKey(tenantId, conversationId);
+    await redis.set(key, JSON.stringify(messages), { ex: getTtl() });
+  } catch (error) {
+    logger.warn("Failed to save agent memory", {
+      tenantId,
+      conversationId,
+      error
+    });
+  }
+}
+async function clearMemory(tenantId, conversationId) {
+  const redis = await tryGetRedis();
+  if (!redis) return;
+  try {
+    await redis.del(memoryKey(tenantId, conversationId));
+  } catch (error) {
+    logger.warn("Failed to clear agent memory", {
+      tenantId,
+      conversationId,
+      error
+    });
+  }
+}
+
+// src/agent.ts
+import { logger as logger2 } from "@nebutra/logger";
+var BaseAgent = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Run the agent with full lifecycle:
+   * 1. Load long-term memory (if configured)
+   * 2. Trim to short-term window
+   * 3. Delegate to provider-specific `execute()`
+   * 4. Track usage for billing
+   * 5. Persist new messages to memory
+   */
+  async run(messages, context) {
+    const startTime = Date.now();
+    const memory = this.config.memory?.longTerm?.enabled ? await getMemory(context.tenantId, context.conversationId) : [];
+    const maxMessages = this.config.memory?.shortTerm?.maxMessages ?? 50;
+    const allMessages = [...memory, ...messages].slice(-maxMessages);
+    const response = await this.execute(allMessages, context);
+    const durationMs = Date.now() - startTime;
+    const usage = {
+      tenantId: context.tenantId,
+      userId: context.userId,
+      agentId: this.config.id,
+      model: this.config.model,
+      promptTokens: response.usage.promptTokens,
+      completionTokens: response.usage.completionTokens,
+      totalTokens: response.usage.totalTokens,
+      durationMs,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    logger2.info("Agent execution completed", {
+      agentId: this.config.id,
+      tenantId: context.tenantId,
+      tokens: usage.totalTokens,
+      durationMs
+    });
+    if (this.config.memory?.longTerm?.enabled) {
+      await saveMemory(context.tenantId, context.conversationId, response.messages);
+    }
+    await this.emitUsage(usage);
+    return response;
+  }
+  /**
+   * Provider-specific execution. Subclasses MUST override this.
+   */
+  async execute(_messages, _context) {
+    throw new Error("execute() must be implemented by provider adapter");
+  }
+  /**
+   * Emit a usage event for downstream billing / metering.
+   */
+  async emitUsage(event) {
+    try {
+      const { deductCredits } = await import("@nebutra/billing/credits");
+      const totalTokens = event.totalTokens || 0;
+      if (totalTokens === 0) return;
+      const creditCost = Math.max(1, Math.ceil(totalTokens / 1e4));
+      await deductCredits({
+        organizationId: event.tenantId,
+        amount: creditCost,
+        description: `Agent execution: ${event.model}`
+      });
+    } catch (err) {
+      logger2.error("Failed to emit usage or deduct credits for agent execution", {
+        tenantId: event.tenantId,
+        agentId: event.agentId,
+        error: err
+      });
+    }
+  }
+};
+
+export {
+  getMemory,
+  saveMemory,
+  clearMemory,
+  BaseAgent
+};

package/dist/chunk-RLWM437Q.js

@@ -0,0 +1,61 @@
+import {
+  resolveApiKey
+} from "./chunk-NVPE5EDI.js";
+import {
+  resolveModel
+} from "./chunk-5JZJ5KMC.js";
+
+// src/sdk/provider.ts
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+function createModel(modelOrPreset, config) {
+  const modelId = resolveModel(modelOrPreset);
+  const apiKey = resolveApiKey(config);
+  switch (config.provider) {
+    case "openrouter": {
+      const provider = createOpenRouter({
+        apiKey,
+        ...config.headers ? { headers: config.headers } : {},
+        ...config.extraBody ? { extraBody: config.extraBody } : {}
+      });
+      return provider.chat(modelId);
+    }
+    case "openai": {
+      const provider = createOpenAI({ apiKey });
+      return provider(modelId);
+    }
+    case "siliconflow": {
+      const provider = createOpenAI({
+        apiKey,
+        baseURL: "https://api.siliconflow.cn/v1"
+      });
+      return provider(modelId);
+    }
+    case "gateway": {
+      const provider = createOpenAI({
+        apiKey,
+        baseURL: "https://ai-gateway.vercel.sh/v1"
+      });
+      return provider(modelId);
+    }
+  }
+}
+function createEmbeddingModel(modelOrPreset, config) {
+  const modelId = resolveModel(modelOrPreset);
+  const apiKey = resolveApiKey(config);
+  if (config.provider !== "openrouter") {
+    throw new Error(
+      `[@nebutra/agents] Embedding models are currently only supported with the "openrouter" provider.`
+    );
+  }
+  const provider = createOpenRouter({
+    apiKey,
+    ...config.headers ? { headers: config.headers } : {}
+  });
+  return provider.textEmbeddingModel(modelId);
+}
+
+export {
+  createModel,
+  createEmbeddingModel
+};

package/dist/chunk-UVL2UVVM.js

@@ -0,0 +1,56 @@
+// src/tools.ts
+var webSearchTool = {
+  name: "web_search",
+  description: "Search the web for current information",
+  inputSchema: {
+    type: "object",
+    properties: { query: { type: "string" } },
+    required: ["query"]
+  },
+  execute: async (_input, _context) => {
+    return {
+      results: [],
+      note: "Configure TAVILY_API_KEY or SERPER_API_KEY for live search"
+    };
+  }
+};
+var databaseQueryTool = {
+  name: "database_query",
+  description: "Query the tenant's database",
+  inputSchema: {
+    type: "object",
+    properties: { query: { type: "string" } },
+    required: ["query"]
+  },
+  execute: async (_input, context) => {
+    return {
+      note: `Query would execute in tenant ${context.tenantId} scope`
+    };
+  }
+};
+var knowledgeBaseTool = {
+  name: "knowledge_base",
+  description: "Search the organization's knowledge base for relevant documents",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string" },
+      limit: { type: "number" }
+    }
+  },
+  execute: async (_input, _context) => {
+    return { documents: [], note: "Configure vector store for RAG" };
+  }
+};
+var BUILT_IN_TOOLS = [
+  webSearchTool,
+  databaseQueryTool,
+  knowledgeBaseTool
+];
+
+export {
+  webSearchTool,
+  databaseQueryTool,
+  knowledgeBaseTool,
+  BUILT_IN_TOOLS
+};