@lupaflow/agent 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,645 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Agent: () => Agent,
+  AgentRunner: () => AgentRunner,
+  ContextManager: () => ContextManager,
+  buildSystemPrompt: () => buildSystemPrompt,
+  validateAgentConfig: () => validateAgentConfig,
+  withRetry: () => withRetry
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/runner.ts
+var import_providers = require("@lupaflow/providers");
+
+// src/context.ts
+var import_core = require("@lupaflow/core");
+var ContextManager = class {
+  messages = [];
+  config;
+  constructor(config = {}) {
+    this.config = {
+      maxMessages: config.maxMessages || 50,
+      maxTokens: config.maxTokens || 4e3,
+      preserveSystem: config.preserveSystem ?? true
+    };
+  }
+  add(message) {
+    this.messages.push(message);
+    this.trim();
+  }
+  getMessages() {
+    return [...this.messages];
+  }
+  getTotalTokens() {
+    return this.messages.reduce((sum, m) => sum + (0, import_core.estimateTokens)(m.content || ""), 0);
+  }
+  trim() {
+    if (this.messages.length <= this.config.maxMessages && this.getTotalTokens() <= this.config.maxTokens) {
+      return;
+    }
+    while (this.messages.length > 2 && (this.messages.length > this.config.maxMessages || this.getTotalTokens() > this.config.maxTokens)) {
+      const startIdx = this.config.preserveSystem && this.messages[0]?.role === "system" ? 1 : 0;
+      if (startIdx < this.messages.length) {
+        this.messages.splice(startIdx, 1);
+      } else {
+        break;
+      }
+    }
+  }
+  clear() {
+    const systemMsg = this.config.preserveSystem ? this.messages.find((m) => m.role === "system") : void 0;
+    this.messages = systemMsg ? [systemMsg] : [];
+  }
+  toJSON() {
+    return this.getMessages();
+  }
+};
+
+// src/retry.ts
+var import_core2 = require("@lupaflow/core");
+var import_core3 = require("@lupaflow/core");
+var import_core4 = require("@lupaflow/core");
+async function withRetry(fn, config = {}, context) {
+  const cfg = {
+    maxRetries: config.maxRetries ?? 3,
+    baseDelay: config.baseDelay ?? 1e3,
+    maxDelay: config.maxDelay ?? 3e4,
+    backoffFactor: config.backoffFactor ?? 2
+  };
+  let lastError = null;
+  for (let attempt = 0; attempt <= cfg.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt < cfg.maxRetries) {
+        const waitTime = Math.min(cfg.baseDelay * Math.pow(cfg.backoffFactor, attempt), cfg.maxDelay);
+        await import_core4.globalEventBus.emit("agent:error", {
+          error: err.message,
+          retryAttempt: attempt + 1
+        });
+        await (0, import_core2.delay)(waitTime);
+      }
+    }
+  }
+  throw new import_core3.RetryError(
+    `${context ? `[${context}] ` : ""}Failed after ${cfg.maxRetries + 1} attempts`,
+    cfg.maxRetries + 1,
+    lastError
+  );
+}
+
+// src/config.ts
+var import_core5 = require("@lupaflow/core");
+function validateAgentConfig(config) {
+  if (!config.name) throw new import_core5.ConfigError("Agent name is required");
+  if (!config.provider) throw new import_core5.ConfigError("Provider is required for agent");
+  if (config.temperature !== void 0 && (config.temperature < 0 || config.temperature > 2)) {
+    throw new import_core5.ConfigError("Temperature must be between 0 and 2");
+  }
+  if (config.maxRetries !== void 0 && config.maxRetries < 0) {
+    throw new import_core5.ConfigError("maxRetries must be >= 0");
+  }
+}
+function buildSystemPrompt(config) {
+  const parts = [];
+  parts.push(config.systemPrompt || `You are ${config.name}, an AI assistant.`);
+  if (config.personality) {
+    const p = config.personality;
+    parts.push("");
+    parts.push("--- Personality ---");
+    if (p.name) parts.push(`Name: ${p.name}`);
+    if (p.tone) parts.push(`Tone: ${p.tone}`);
+    if (p.style) parts.push(`Style: ${p.style}`);
+    if (p.traits?.length) parts.push(`Traits: ${p.traits.join(", ")}`);
+  }
+  if (config.goals?.length) {
+    parts.push("");
+    parts.push("--- Goals ---");
+    config.goals.forEach((g, i) => parts.push(`${i + 1}. ${g.description}`));
+  }
+  if (config.constraints?.length) {
+    parts.push("");
+    parts.push("--- Constraints ---");
+    config.constraints.forEach((c) => parts.push(`- ${c.description}`));
+  }
+  if (config.tools?.length) {
+    parts.push("");
+    parts.push(`You have access to these tools: ${config.tools.map((t) => t.definition.name).join(", ")}`);
+    parts.push("Use them when appropriate to fulfill the user's request.");
+  }
+  return parts.join("\n");
+}
+
+// src/runner.ts
+var import_core6 = require("@lupaflow/core");
+var import_core7 = require("@lupaflow/core");
+var import_core8 = require("@lupaflow/core");
+var import_plugins = require("@lupaflow/plugins");
+var AgentRunner = class {
+  config;
+  context;
+  memory;
+  toolCallCount = 0;
+  totalPromptTokens = 0;
+  totalCompletionTokens = 0;
+  constructor(config, memory) {
+    this.config = config;
+    this.context = new ContextManager({
+      maxMessages: config.maxContextMessages || 50
+    });
+    this.memory = memory;
+  }
+  async run(options) {
+    const runId = (0, import_core6.generateId)();
+    const startTime = Date.now();
+    this.toolCallCount = 0;
+    this.totalPromptTokens = 0;
+    this.totalCompletionTokens = 0;
+    const provider = import_providers.providerRegistry.get(this.config.provider, {
+      model: this.config.model,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      topP: this.config.topP
+    });
+    const systemPrompt = buildSystemPrompt(this.config);
+    (0, import_plugins.runBeforeAgentRunHooks)({
+      input: options.input,
+      ...this.config
+    });
+    this.context.add({ role: "system", content: systemPrompt });
+    this.context.add({ role: "user", content: options.input });
+    await import_core7.globalEventBus.emit("agent:start", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      config: this.config
+    });
+    await import_core7.globalEventBus.emit("agent:thinking", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      message: options.input
+    });
+    let finalContent = "";
+    let finishReason = "stop";
+    let iterationCount = 0;
+    const maxIterations = 20;
+    while (iterationCount < maxIterations) {
+      iterationCount++;
+      const request = (0, import_plugins.runBeforeProviderCallHooks)(this.config.provider, {
+        model: this.config.model,
+        messages: this.context.getMessages(),
+        tools: this.config.tools,
+        systemPrompt: void 0,
+        temperature: this.config.temperature,
+        maxTokens: this.config.maxTokens,
+        topP: this.config.topP
+      });
+      const response = await withRetry(
+        () => provider.complete({
+          messages: request.messages || this.context.getMessages(),
+          tools: this.config.tools,
+          systemPrompt: void 0,
+          temperature: this.config.temperature,
+          maxTokens: this.config.maxTokens,
+          topP: this.config.topP,
+          model: this.config.model
+        }),
+        {
+          maxRetries: this.config.maxRetries ?? 3,
+          baseDelay: this.config.retryDelay ?? 1e3
+        },
+        this.config.name
+      );
+      (0, import_plugins.runAfterProviderCallHooks)(response);
+      this.totalPromptTokens += response.usage.promptTokens;
+      this.totalCompletionTokens += response.usage.completionTokens;
+      if (response.toolCalls.length > 0) {
+        this.context.add({
+          role: "assistant",
+          content: response.content || null,
+          toolCalls: response.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: { name: tc.name, arguments: JSON.stringify(tc.args) }
+          }))
+        });
+      } else if (response.content) {
+        this.context.add({ role: "assistant", content: response.content });
+      }
+      if (response.toolCalls.length === 0) {
+        finalContent = response.content || "";
+        finishReason = response.finishReason;
+        break;
+      }
+      for (const tc of response.toolCalls) {
+        this.toolCallCount++;
+        await import_core7.globalEventBus.emit("tool:start", {
+          agentId: this.config.id || this.config.name,
+          runId,
+          tool: tc.name,
+          args: tc.args
+        });
+        options.onToolCall?.(tc.name, tc.args);
+        try {
+          const tool = this.config.tools?.find((t) => t.definition.name === tc.name);
+          if (!tool) throw new import_core8.ToolError(tc.name, `Tool "${tc.name}" not found on agent`);
+          const hookArgs = (0, import_plugins.runBeforeToolCallHooks)(tc.name, tc.args);
+          const result = await tool.execute(hookArgs);
+          const hookResult = (0, import_plugins.runAfterToolCallHooks)(result);
+          const resultStr = typeof hookResult === "string" ? hookResult : JSON.stringify(hookResult, null, 2);
+          this.context.add({
+            role: "tool",
+            toolCallId: tc.id,
+            name: tc.name,
+            content: resultStr
+          });
+          await import_core7.globalEventBus.emit("tool:finish", {
+            agentId: this.config.id || this.config.name,
+            runId,
+            tool: tc.name,
+            result: hookResult,
+            durationMs: Date.now() - startTime
+          });
+          options.onToolResult?.(tc.name, hookResult);
+        } catch (err) {
+          this.context.add({
+            role: "tool",
+            toolCallId: tc.id,
+            name: tc.name,
+            content: `Error: ${err.message}`
+          });
+          await import_core7.globalEventBus.emit("tool:error", {
+            agentId: this.config.id || this.config.name,
+            runId,
+            tool: tc.name,
+            error: err.message
+          });
+        }
+      }
+    }
+    const totalLatency = Date.now() - startTime;
+    if (this.memory) {
+      await this.memory.store({
+        id: (0, import_core6.generateId)(),
+        type: "short-term",
+        key: `agent:${this.config.name}:input:${(0, import_core6.generateId)()}`,
+        content: options.input,
+        metadata: { runId, agentName: this.config.name },
+        timestamp: Date.now()
+      });
+      if (finalContent) {
+        await this.memory.store({
+          id: (0, import_core6.generateId)(),
+          type: "short-term",
+          key: `agent:${this.config.name}:output:${(0, import_core6.generateId)()}`,
+          content: finalContent,
+          metadata: { runId, agentName: this.config.name },
+          timestamp: Date.now()
+        });
+      }
+    }
+    await import_core7.globalEventBus.emit("agent:response", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      content: finalContent,
+      tokens: this.totalCompletionTokens,
+      latencyMs: totalLatency
+    });
+    (0, import_plugins.runAfterAgentRunHooks)({
+      id: runId,
+      output: finalContent,
+      messages: this.context.getMessages(),
+      usage: {
+        totalTokens: this.totalPromptTokens + this.totalCompletionTokens,
+        promptTokens: this.totalPromptTokens,
+        completionTokens: this.totalCompletionTokens
+      },
+      latencyMs: totalLatency,
+      toolCalls: this.toolCallCount,
+      finishReason
+    });
+    await import_core7.globalEventBus.emit("agent:complete", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      totalTokens: this.totalPromptTokens + this.totalCompletionTokens,
+      totalLatencyMs: totalLatency,
+      toolCalls: this.toolCallCount
+    });
+    return {
+      id: runId,
+      output: finalContent,
+      messages: this.context.getMessages(),
+      usage: {
+        totalTokens: this.totalPromptTokens + this.totalCompletionTokens,
+        promptTokens: this.totalPromptTokens,
+        completionTokens: this.totalCompletionTokens
+      },
+      latencyMs: totalLatency,
+      toolCalls: this.toolCallCount,
+      finishReason
+    };
+  }
+  async *streamRun(options) {
+    const runId = (0, import_core6.generateId)();
+    const startTime = Date.now();
+    this.toolCallCount = 0;
+    this.totalPromptTokens = 0;
+    this.totalCompletionTokens = 0;
+    const provider = import_providers.providerRegistry.get(this.config.provider, {
+      model: this.config.model,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      topP: this.config.topP
+    });
+    const systemPrompt = buildSystemPrompt(this.config);
+    (0, import_plugins.runBeforeAgentRunHooks)({
+      input: options.input,
+      ...this.config
+    });
+    this.context.add({ role: "system", content: systemPrompt });
+    this.context.add({ role: "user", content: options.input });
+    await import_core7.globalEventBus.emit("agent:start", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      config: this.config
+    });
+    await import_core7.globalEventBus.emit("agent:thinking", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      message: options.input
+    });
+    let finalContent = "";
+    let finishReason = "stop";
+    let iterationCount = 0;
+    const maxIterations = 20;
+    while (iterationCount < maxIterations) {
+      iterationCount++;
+      const request = (0, import_plugins.runBeforeProviderCallHooks)(this.config.provider, {
+        model: this.config.model,
+        messages: this.context.getMessages(),
+        tools: this.config.tools,
+        systemPrompt: void 0,
+        temperature: this.config.temperature,
+        maxTokens: this.config.maxTokens,
+        topP: this.config.topP
+      });
+      const messages = request.messages || this.context.getMessages();
+      const stream = provider.streamComplete({
+        messages,
+        tools: this.config.tools,
+        systemPrompt: void 0,
+        temperature: this.config.temperature,
+        maxTokens: this.config.maxTokens,
+        topP: this.config.topP,
+        model: this.config.model
+      });
+      let roundContent = "";
+      let roundToolCalls = [];
+      for await (const chunk of stream) {
+        if (chunk.type === "text") {
+          roundContent += chunk.text;
+          yield { type: "text", text: chunk.text };
+        } else if (chunk.type === "tool_call") {
+          roundToolCalls.push(chunk.toolCall);
+        } else if (chunk.type === "finish") {
+          roundContent = chunk.content;
+          roundToolCalls = chunk.toolCalls;
+          this.totalPromptTokens += chunk.usage.promptTokens;
+          this.totalCompletionTokens += chunk.usage.completionTokens;
+          finishReason = chunk.finishReason;
+        }
+      }
+      (0, import_plugins.runAfterProviderCallHooks)({
+        content: roundContent,
+        toolCalls: roundToolCalls
+      });
+      if (roundToolCalls.length > 0) {
+        this.context.add({
+          role: "assistant",
+          content: roundContent || null,
+          toolCalls: roundToolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: { name: tc.name, arguments: JSON.stringify(tc.args) }
+          }))
+        });
+      } else if (roundContent) {
+        this.context.add({ role: "assistant", content: roundContent });
+      }
+      if (roundToolCalls.length === 0) {
+        finalContent = roundContent;
+        finishReason = finishReason || "stop";
+        break;
+      }
+      for (const tc of roundToolCalls) {
+        this.toolCallCount++;
+        await import_core7.globalEventBus.emit("tool:start", {
+          agentId: this.config.id || this.config.name,
+          runId,
+          tool: tc.name,
+          args: tc.args
+        });
+        options.onToolCall?.(tc.name, tc.args);
+        yield { type: "tool_call", toolCall: tc };
+        try {
+          const tool = this.config.tools?.find((t) => t.definition.name === tc.name);
+          if (!tool) throw new import_core8.ToolError(tc.name, `Tool "${tc.name}" not found on agent`);
+          const hookArgs = (0, import_plugins.runBeforeToolCallHooks)(tc.name, tc.args);
+          const result = await tool.execute(hookArgs);
+          const hookResult = (0, import_plugins.runAfterToolCallHooks)(result);
+          const resultStr = typeof hookResult === "string" ? hookResult : JSON.stringify(hookResult, null, 2);
+          this.context.add({
+            role: "tool",
+            toolCallId: tc.id,
+            name: tc.name,
+            content: resultStr
+          });
+          await import_core7.globalEventBus.emit("tool:finish", {
+            agentId: this.config.id || this.config.name,
+            runId,
+            tool: tc.name,
+            result: hookResult,
+            durationMs: Date.now() - startTime
+          });
+          options.onToolResult?.(tc.name, hookResult);
+          yield { type: "tool_result", toolCall: tc, result: hookResult };
+        } catch (err) {
+          this.context.add({
+            role: "tool",
+            toolCallId: tc.id,
+            name: tc.name,
+            content: `Error: ${err.message}`
+          });
+          await import_core7.globalEventBus.emit("tool:error", {
+            agentId: this.config.id || this.config.name,
+            runId,
+            tool: tc.name,
+            error: err.message
+          });
+          yield { type: "error", error: err.message };
+        }
+      }
+    }
+    const totalLatency = Date.now() - startTime;
+    if (this.memory) {
+      await this.memory.store({
+        id: (0, import_core6.generateId)(),
+        type: "short-term",
+        key: `agent:${this.config.name}:input:${(0, import_core6.generateId)()}`,
+        content: options.input,
+        metadata: { runId, agentName: this.config.name },
+        timestamp: Date.now()
+      });
+      if (finalContent) {
+        await this.memory.store({
+          id: (0, import_core6.generateId)(),
+          type: "short-term",
+          key: `agent:${this.config.name}:output:${(0, import_core6.generateId)()}`,
+          content: finalContent,
+          metadata: { runId, agentName: this.config.name },
+          timestamp: Date.now()
+        });
+      }
+    }
+    await import_core7.globalEventBus.emit("agent:response", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      content: finalContent,
+      tokens: this.totalCompletionTokens,
+      latencyMs: totalLatency
+    });
+    (0, import_plugins.runAfterAgentRunHooks)({
+      id: runId,
+      output: finalContent,
+      messages: this.context.getMessages(),
+      usage: {
+        totalTokens: this.totalPromptTokens + this.totalCompletionTokens,
+        promptTokens: this.totalPromptTokens,
+        completionTokens: this.totalCompletionTokens
+      },
+      latencyMs: totalLatency,
+      toolCalls: this.toolCallCount,
+      finishReason
+    });
+    await import_core7.globalEventBus.emit("agent:complete", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      totalTokens: this.totalPromptTokens + this.totalCompletionTokens,
+      totalLatencyMs: totalLatency,
+      toolCalls: this.toolCallCount
+    });
+    yield {
+      type: "finish",
+      output: finalContent,
+      finishReason,
+      usage: {
+        totalTokens: this.totalPromptTokens + this.totalCompletionTokens,
+        promptTokens: this.totalPromptTokens,
+        completionTokens: this.totalCompletionTokens
+      },
+      toolCalls: this.toolCallCount,
+      latencyMs: totalLatency
+    };
+  }
+};
+
+// src/agent.ts
+var import_core9 = require("@lupaflow/core");
+var import_tools = require("@lupaflow/tools");
+var Agent = class {
+  config;
+  memoryStore;
+  constructor(config) {
+    validateAgentConfig(config);
+    this.config = {
+      ...config,
+      id: config.id || (0, import_core9.generateId)()
+    };
+  }
+  tool(t) {
+    this.config.tools = this.config.tools || [];
+    this.config.tools.push(t);
+    return this;
+  }
+  useTool(name) {
+    try {
+      const tool = import_tools.toolRegistry.get(name);
+      this.config.tools = this.config.tools || [];
+      this.config.tools.push(tool);
+    } catch {
+      throw new Error(`Tool "${name}" not found in registry`);
+    }
+    return this;
+  }
+  memory(memory) {
+    this.memoryStore = memory;
+    return this;
+  }
+  personality(p) {
+    this.config.personality = p;
+    return this;
+  }
+  goal(g) {
+    this.config.goals = this.config.goals || [];
+    this.config.goals.push(g);
+    return this;
+  }
+  constraint(c) {
+    this.config.constraints = this.config.constraints || [];
+    this.config.constraints.push(c);
+    return this;
+  }
+  temperature(t) {
+    this.config.temperature = t;
+    return this;
+  }
+  model(m) {
+    this.config.model = m;
+    return this;
+  }
+  async run(input, options) {
+    const runner = new AgentRunner(this.config, this.memoryStore);
+    return runner.run({
+      input,
+      ...options
+    });
+  }
+  async *streamRun(input, options) {
+    const runner = new AgentRunner(this.config, this.memoryStore);
+    yield* runner.streamRun({
+      input,
+      ...options
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Agent,
+  AgentRunner,
+  ContextManager,
+  buildSystemPrompt,
+  validateAgentConfig,
+  withRetry
+});
+//# sourceMappingURL=index.cjs.map