@avee1234/agent-kit 0.1.0

package/dist/index.js

@@ -0,0 +1,619 @@
+// src/model/mock.ts
+var MockAdapter = class {
+  async chat(messages, tools) {
+    const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
+    const content = lastUserMsg?.content ?? "";
+    const systemMsg = messages.find((m) => m.role === "system");
+    if (systemMsg?.content.toLowerCase().includes("summarize")) {
+      const conversationContent = messages.filter((m) => m.role !== "system").map((m) => m.content).join(" ");
+      return { content: `[Mock Summary] ${conversationContent.slice(0, 200)}` };
+    }
+    if (tools?.length) {
+      for (const tool of tools) {
+        const toolNameWords = tool.name.replace(/_/g, " ").split(" ");
+        const matches = toolNameWords.some(
+          (word) => content.toLowerCase().includes(word.toLowerCase())
+        );
+        if (matches) {
+          return {
+            content: "",
+            toolCalls: [
+              {
+                id: `mock-tc-${Date.now()}`,
+                name: tool.name,
+                arguments: JSON.stringify(
+                  Object.fromEntries(Object.keys(tool.parameters).map((key) => [key, content]))
+                )
+              }
+            ]
+          };
+        }
+      }
+    }
+    return {
+      content: `[Mock] Received: "${content}". Tools available: ${tools?.map((t) => t.name).join(", ") ?? "none"}.`
+    };
+  }
+  async *stream(messages, tools) {
+    const response = await this.chat(messages, tools);
+    const words = response.content.split(" ");
+    for (let i = 0; i < words.length; i++) {
+      yield {
+        text: (i > 0 ? " " : "") + words[i],
+        done: i === words.length - 1,
+        ...i === words.length - 1 && response.toolCalls ? { toolCalls: response.toolCalls } : {}
+      };
+    }
+  }
+};
+
+// src/model/openai-compatible.ts
+var OpenAICompatibleAdapter = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async chat(messages, tools) {
+    const body = {
+      model: this.config.model,
+      messages: messages.map((m) => this.toOpenAIMessage(m))
+    };
+    if (tools?.length) {
+      body.tools = tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: { type: "object", properties: t.parameters }
+        }
+      }));
+    }
+    const headers = { "Content-Type": "application/json" };
+    if (this.config.apiKey) headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    const response = await fetch(`${this.config.baseURL}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Model API error (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    const choice = data.choices[0].message;
+    const result = { content: choice.content ?? "" };
+    if (choice.tool_calls?.length) {
+      result.toolCalls = choice.tool_calls.map(
+        (tc) => ({
+          id: tc.id,
+          name: tc.function.name,
+          arguments: tc.function.arguments
+        })
+      );
+    }
+    if (data.usage) {
+      result.tokens = { input: data.usage.prompt_tokens, output: data.usage.completion_tokens };
+    }
+    return result;
+  }
+  async *stream(messages, tools) {
+    const headers = { "Content-Type": "application/json" };
+    if (this.config.apiKey) headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    const body = {
+      model: this.config.model,
+      messages: messages.map((m) => this.toOpenAIMessage(m)),
+      stream: true
+    };
+    if (tools?.length) {
+      body.tools = tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: { type: "object", properties: t.parameters }
+        }
+      }));
+    }
+    const response = await fetch(`${this.config.baseURL}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Model API error (${response.status}): ${errorText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("No response body");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") {
+          yield { text: "", done: true };
+          return;
+        }
+        const parsed = JSON.parse(data);
+        const delta = parsed.choices?.[0]?.delta;
+        if (delta?.content) yield { text: delta.content, done: false };
+      }
+    }
+  }
+  toOpenAIMessage(msg) {
+    const result = { role: msg.role, content: msg.content };
+    if (msg.toolCalls) {
+      result.tool_calls = msg.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: tc.arguments }
+      }));
+    }
+    if (msg.toolCallId) result.tool_call_id = msg.toolCallId;
+    return result;
+  }
+};
+
+// src/events.ts
+var AgentEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(type, handler) {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(type).add(handler);
+  }
+  off(type, handler) {
+    this.listeners.get(type)?.delete(handler);
+  }
+  emit(event) {
+    this.listeners.get(event.type)?.forEach((handler) => handler(event));
+    if (event.type !== "*") {
+      this.listeners.get("*")?.forEach((handler) => handler(event));
+    }
+  }
+};
+
+// src/types.ts
+function createMessage(opts) {
+  return {
+    ...opts,
+    timestamp: opts.timestamp ?? Date.now()
+  };
+}
+function isToolCallMessage(msg) {
+  return Array.isArray(msg.toolCalls) && msg.toolCalls.length > 0;
+}
+function createSummary(opts) {
+  return {
+    id: opts.id ?? crypto.randomUUID(),
+    content: opts.content,
+    timestamp: opts.timestamp ?? Date.now(),
+    messageRange: opts.messageRange ?? { from: 0, to: 0 }
+  };
+}
+
+// src/agent.ts
+var Agent = class {
+  name;
+  model;
+  memory;
+  tools;
+  toolMap;
+  system;
+  maxToolRounds;
+  emitter;
+  constructor(config) {
+    this.name = config.name;
+    this.memory = config.memory;
+    this.tools = config.tools ?? [];
+    this.system = config.system;
+    this.maxToolRounds = config.maxToolRounds ?? 10;
+    this.emitter = new AgentEventEmitter();
+    this.toolMap = new Map(this.tools.map((t) => [t.name, t]));
+    if (!config.model) {
+      this.model = new MockAdapter();
+    } else if (this.isModelAdapter(config.model)) {
+      this.model = config.model;
+    } else {
+      const cfg = config.model;
+      const baseURL = cfg.provider === "ollama" ? cfg.baseURL ?? "http://localhost:11434/v1" : cfg.baseURL ?? "http://localhost:11434/v1";
+      this.model = new OpenAICompatibleAdapter({
+        baseURL,
+        model: cfg.model,
+        apiKey: cfg.apiKey
+      });
+    }
+    if (this.memory) {
+      this.memory.setModel(this.model);
+    }
+  }
+  isModelAdapter(obj) {
+    return typeof obj.chat === "function";
+  }
+  on(type, handler) {
+    this.emitter.on(type, handler);
+  }
+  off(type, handler) {
+    this.emitter.off(type, handler);
+  }
+  emit(type, data, extras) {
+    this.emitter.emit({
+      type,
+      timestamp: Date.now(),
+      agentId: this.name,
+      data,
+      ...extras
+    });
+  }
+  async chat(input) {
+    const toolDefs = this.tools.map((t) => t.definition);
+    const messages = [];
+    if (this.system) {
+      messages.push(createMessage({ role: "system", content: this.system }));
+    }
+    if (this.memory) {
+      const ctx = await this.memory.getContext(this.name, input);
+      this.emit("memory:retrieve", {
+        summaries: ctx.relevantSummaries.length,
+        recentMessages: ctx.recentMessages.length
+      });
+      for (const summary of ctx.relevantSummaries) {
+        messages.push(
+          createMessage({
+            role: "system",
+            content: `[Previous conversation summary]: ${summary.content}`,
+            timestamp: summary.timestamp
+          })
+        );
+      }
+      messages.push(...ctx.recentMessages);
+    }
+    const userMessage = createMessage({ role: "user", content: input });
+    messages.push(userMessage);
+    this.emit("message", { role: "user", content: input });
+    let response = { content: "" };
+    let toolRoundsUsed = 0;
+    response = await this.model.chat(messages, toolDefs.length ? toolDefs : void 0);
+    while (isToolCallMessage({ ...response, role: "assistant", timestamp: Date.now() }) && toolRoundsUsed < this.maxToolRounds) {
+      const assistantMsg = createMessage({
+        role: "assistant",
+        content: response.content,
+        toolCalls: response.toolCalls
+      });
+      messages.push(assistantMsg);
+      for (const toolCall of response.toolCalls ?? []) {
+        const tool = this.toolMap.get(toolCall.name);
+        const startTime = Date.now();
+        this.emit("tool:start", {
+          toolName: toolCall.name,
+          toolCallId: toolCall.id,
+          arguments: toolCall.arguments
+        });
+        let toolResult;
+        if (!tool) {
+          toolResult = `Error: tool "${toolCall.name}" not found`;
+          this.emit("error", {
+            message: `Tool not found: ${toolCall.name}`,
+            toolCallId: toolCall.id
+          });
+        } else {
+          try {
+            let parsedArgs = {};
+            try {
+              parsedArgs = JSON.parse(toolCall.arguments);
+            } catch {
+              parsedArgs = {};
+            }
+            const result = await tool.execute(parsedArgs);
+            toolResult = typeof result === "string" ? result : JSON.stringify(result);
+          } catch (err) {
+            const error = err;
+            toolResult = `Error: ${error.message}`;
+            this.emit("error", {
+              message: error.message,
+              toolCallId: toolCall.id,
+              toolName: toolCall.name
+            });
+          }
+        }
+        const latencyMs = Date.now() - startTime;
+        this.emit("tool:end", {
+          toolName: toolCall.name,
+          toolCallId: toolCall.id,
+          result: toolResult,
+          latencyMs
+        });
+        messages.push(
+          createMessage({
+            role: "tool",
+            content: toolResult,
+            toolCallId: toolCall.id
+          })
+        );
+      }
+      toolRoundsUsed++;
+      response = await this.model.chat(messages, toolDefs.length ? toolDefs : void 0);
+    }
+    this.emit("message", { role: "assistant", content: response.content });
+    if (this.memory) {
+      const exchangeMessages = [
+        userMessage,
+        createMessage({
+          role: "assistant",
+          content: response.content,
+          toolCalls: response.toolCalls
+        })
+      ];
+      await this.memory.saveExchange(this.name, exchangeMessages);
+    }
+    return response;
+  }
+  async *stream(input) {
+    const toolDefs = this.tools.map((t) => t.definition);
+    const messages = [];
+    if (this.system) {
+      messages.push(createMessage({ role: "system", content: this.system }));
+    }
+    if (this.memory) {
+      const ctx = await this.memory.getContext(this.name, input);
+      for (const summary of ctx.relevantSummaries) {
+        messages.push(
+          createMessage({
+            role: "system",
+            content: `[Previous conversation summary]: ${summary.content}`,
+            timestamp: summary.timestamp
+          })
+        );
+      }
+      messages.push(...ctx.recentMessages);
+    }
+    const userMessage = createMessage({ role: "user", content: input });
+    messages.push(userMessage);
+    this.emit("message", { role: "user", content: input });
+    let fullText = "";
+    for await (const chunk of this.model.stream(messages, toolDefs.length ? toolDefs : void 0)) {
+      fullText += chunk.text;
+      yield chunk;
+    }
+    this.emit("message", { role: "assistant", content: fullText });
+    if (this.memory) {
+      await this.memory.saveExchange(this.name, [
+        userMessage,
+        createMessage({ role: "assistant", content: fullText })
+      ]);
+    }
+  }
+};
+
+// src/tool.ts
+var Tool = class _Tool {
+  name;
+  description;
+  definition;
+  executeFn;
+  constructor(config) {
+    this.name = config.name;
+    this.description = config.description;
+    this.definition = {
+      name: config.name,
+      description: config.description,
+      parameters: config.parameters
+    };
+    this.executeFn = config.execute;
+  }
+  static create(config) {
+    return new _Tool(config);
+  }
+  async execute(params) {
+    return this.executeFn(params);
+  }
+};
+
+// src/store/in-memory.ts
+var InMemoryStore = class {
+  messages = /* @__PURE__ */ new Map();
+  summaries = /* @__PURE__ */ new Map();
+  async saveMessages(agentId, messages) {
+    const existing = this.messages.get(agentId) ?? [];
+    existing.push(...messages);
+    this.messages.set(agentId, existing);
+  }
+  async getRecentMessages(agentId, limit) {
+    const all = this.messages.get(agentId) ?? [];
+    return all.slice(-limit);
+  }
+  async saveSummary(agentId, summary) {
+    const existing = this.summaries.get(agentId) ?? [];
+    existing.push(summary);
+    this.summaries.set(agentId, existing);
+  }
+  async searchSummaries(agentId, query, limit) {
+    const all = this.summaries.get(agentId) ?? [];
+    const queryLower = query.toLowerCase();
+    const matches = all.filter((s) => s.content.toLowerCase().includes(queryLower)).sort((a, b) => b.timestamp - a.timestamp).slice(0, limit);
+    return matches;
+  }
+};
+
+// src/store/sqlite.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var SQLiteStore = class {
+  db;
+  constructor(path) {
+    const Database = require2("better-sqlite3");
+    this.db = new Database(path);
+    this.db.pragma("journal_mode = WAL");
+    this.init();
+  }
+  init() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        tool_calls TEXT,
+        tool_call_id TEXT
+      );
+      CREATE TABLE IF NOT EXISTS summaries (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        content TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        message_range_from INTEGER NOT NULL,
+        message_range_to INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_messages_agent ON messages(agent_id);
+      CREATE INDEX IF NOT EXISTS idx_summaries_agent ON summaries(agent_id);
+    `);
+  }
+  async saveMessages(agentId, messages) {
+    const stmt = this.db.prepare(
+      "INSERT INTO messages (agent_id, role, content, timestamp, tool_calls, tool_call_id) VALUES (?, ?, ?, ?, ?, ?)"
+    );
+    const insertMany = this.db.transaction((msgs) => {
+      for (const msg of msgs) {
+        stmt.run(
+          agentId,
+          msg.role,
+          msg.content,
+          msg.timestamp,
+          msg.toolCalls ? JSON.stringify(msg.toolCalls) : null,
+          msg.toolCallId ?? null
+        );
+      }
+    });
+    insertMany(messages);
+  }
+  async getRecentMessages(agentId, limit) {
+    const rows = this.db.prepare(
+      `SELECT role, content, timestamp, tool_calls, tool_call_id
+       FROM messages WHERE agent_id = ?
+       ORDER BY id DESC LIMIT ?`
+    ).all(agentId, limit);
+    return rows.reverse().map((row) => ({
+      role: row.role,
+      content: row.content,
+      timestamp: row.timestamp,
+      ...row.tool_calls ? { toolCalls: JSON.parse(row.tool_calls) } : {},
+      ...row.tool_call_id ? { toolCallId: row.tool_call_id } : {}
+    }));
+  }
+  async saveSummary(agentId, summary) {
+    this.db.prepare(
+      "INSERT INTO summaries (id, agent_id, content, timestamp, message_range_from, message_range_to) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(
+      summary.id,
+      agentId,
+      summary.content,
+      summary.timestamp,
+      summary.messageRange.from,
+      summary.messageRange.to
+    );
+  }
+  async searchSummaries(agentId, query, limit) {
+    const rows = this.db.prepare(
+      `SELECT id, content, timestamp, message_range_from, message_range_to
+       FROM summaries WHERE agent_id = ? AND content LIKE ?
+       ORDER BY timestamp DESC LIMIT ?`
+    ).all(agentId, `%${query}%`, limit);
+    return rows.map((row) => ({
+      id: row.id,
+      content: row.content,
+      timestamp: row.timestamp,
+      messageRange: { from: row.message_range_from, to: row.message_range_to }
+    }));
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/memory.ts
+var Memory = class {
+  store;
+  windowSize;
+  summarizeAfter;
+  model;
+  messageCount = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.windowSize = config.windowSize ?? 20;
+    this.summarizeAfter = config.summarizeAfter ?? 20;
+    if (!config.store || config.store === "memory") {
+      this.store = new InMemoryStore();
+    } else if (config.store === "sqlite") {
+      this.store = new SQLiteStore(config.path ?? "./agent-memory.db");
+    } else {
+      this.store = config.store;
+    }
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  getStore() {
+    return this.store;
+  }
+  async saveExchange(agentId, messages) {
+    await this.store.saveMessages(agentId, messages);
+    const count = (this.messageCount.get(agentId) ?? 0) + messages.length;
+    this.messageCount.set(agentId, count);
+    if (count >= this.summarizeAfter && this.model) {
+      await this.summarize(agentId);
+      this.messageCount.set(agentId, 0);
+    }
+  }
+  async getContext(agentId, query) {
+    const recentMessages = await this.store.getRecentMessages(agentId, this.windowSize);
+    const relevantSummaries = await this.store.searchSummaries(agentId, query, 3);
+    return { recentMessages, relevantSummaries };
+  }
+  async summarize(agentId) {
+    if (!this.model) return;
+    const allRecent = await this.store.getRecentMessages(agentId, this.summarizeAfter);
+    if (allRecent.length === 0) return;
+    const summaryResponse = await this.model.chat([
+      {
+        role: "system",
+        content: "Summarize the following conversation concisely. Focus on key topics, decisions, and facts discussed.",
+        timestamp: Date.now()
+      },
+      ...allRecent
+    ]);
+    const summary = createSummary({
+      content: summaryResponse.content,
+      messageRange: {
+        from: allRecent[0].timestamp,
+        to: allRecent[allRecent.length - 1].timestamp
+      }
+    });
+    await this.store.saveSummary(agentId, summary);
+  }
+  close() {
+    if ("close" in this.store && typeof this.store.close === "function") {
+      this.store.close();
+    }
+  }
+};
+export {
+  Agent,
+  AgentEventEmitter,
+  InMemoryStore,
+  Memory,
+  MockAdapter,
+  OpenAICompatibleAdapter,
+  SQLiteStore,
+  Tool,
+  createMessage,
+  createSummary,
+  isToolCallMessage
+};
+//# sourceMappingURL=index.js.map