@avee1234/agent-kit 0.2.0 → 0.3.1

package/dist/index.js

@@ -64,7 +64,15 @@ var OpenAICompatibleAdapter = class {
         function: {
           name: t.name,
           description: t.description,
-          parameters: { type: "object", properties: t.parameters }
+          parameters: {
+            type: "object",
+            properties: Object.fromEntries(
+              Object.entries(t.parameters).map(([key, val]) => {
+                const { required: _req, ...rest } = val;
+                return [key, rest];
+              })
+            )
+          }
         }
       }));
     }
@@ -110,7 +118,15 @@ var OpenAICompatibleAdapter = class {
         function: {
           name: t.name,
           description: t.description,
-          parameters: { type: "object", properties: t.parameters }
+          parameters: {
+            type: "object",
+            properties: Object.fromEntries(
+              Object.entries(t.parameters).map(([key, val]) => {
+                const { required: _req, ...rest } = val;
+                return [key, rest];
+              })
+            )
+          }
         }
       }));
     }
@@ -572,13 +588,11 @@ var HierarchicalStrategy = class {
       parameters: {
         agentName: {
           type: "string",
-          description: "The name of the agent to delegate to",
-          required: true
+          description: `The name of the agent to delegate to. Available: ${[...agents.map((a) => a.name)].join(", ")}`
         },
         task: {
           type: "string",
-          description: "The task to assign to the agent",
-          required: true
+          description: "The task to assign to the agent"
         }
       },
       execute: async (params) => {
@@ -687,10 +701,27 @@ var Team = class {
   }
 };
 
+// src/store/cosine.ts
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denom === 0) return 0;
+  return dot / denom;
+}
+
 // src/store/in-memory.ts
 var InMemoryStore = class {
   messages = /* @__PURE__ */ new Map();
   summaries = /* @__PURE__ */ new Map();
+  // agentId -> (summaryId -> embedding vector)
+  embeddings = /* @__PURE__ */ new Map();
   async saveMessages(agentId, messages) {
     const existing = this.messages.get(agentId) ?? [];
     existing.push(...messages);
@@ -711,6 +742,28 @@ var InMemoryStore = class {
     const matches = all.filter((s) => s.content.toLowerCase().includes(queryLower)).sort((a, b) => b.timestamp - a.timestamp).slice(0, limit);
     return matches;
   }
+  async saveEmbedding(agentId, summaryId, embedding) {
+    let agentMap = this.embeddings.get(agentId);
+    if (!agentMap) {
+      agentMap = /* @__PURE__ */ new Map();
+      this.embeddings.set(agentId, agentMap);
+    }
+    agentMap.set(summaryId, embedding);
+  }
+  async searchByEmbedding(agentId, embedding, limit) {
+    const agentMap = this.embeddings.get(agentId);
+    if (!agentMap || agentMap.size === 0) return [];
+    const summaries = this.summaries.get(agentId) ?? [];
+    const summaryById = new Map(summaries.map((s) => [s.id, s]));
+    const scored = [];
+    for (const [summaryId, storedEmbedding] of agentMap) {
+      const summary = summaryById.get(summaryId);
+      if (!summary) continue;
+      const score = cosineSimilarity(embedding, storedEmbedding);
+      scored.push({ summary, score });
+    }
+    return scored.sort((a, b) => b.score - a.score).slice(0, limit).map((entry) => entry.summary);
+  }
 };
 
 // src/store/sqlite.ts
@@ -743,8 +796,14 @@ var SQLiteStore = class {
         message_range_from INTEGER NOT NULL,
         message_range_to INTEGER NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS embeddings (
+        summary_id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        embedding BLOB 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);
+      CREATE INDEX IF NOT EXISTS idx_embeddings_agent ON embeddings(agent_id);
     `);
   }
   async saveMessages(agentId, messages) {
@@ -804,25 +863,208 @@ var SQLiteStore = class {
       messageRange: { from: row.message_range_from, to: row.message_range_to }
     }));
   }
+  async saveEmbedding(agentId, summaryId, embedding) {
+    this.db.prepare(
+      "INSERT OR REPLACE INTO embeddings (summary_id, agent_id, embedding) VALUES (?, ?, ?)"
+    ).run(summaryId, agentId, JSON.stringify(embedding));
+  }
+  async searchByEmbedding(agentId, embedding, limit) {
+    const rows = this.db.prepare(
+      `SELECT e.summary_id, s.content, s.timestamp, s.message_range_from, s.message_range_to, e.embedding
+         FROM embeddings e
+         JOIN summaries s ON e.summary_id = s.id
+         WHERE e.agent_id = ?`
+    ).all(agentId);
+    if (rows.length === 0) return [];
+    const scored = rows.map((row) => {
+      const storedEmbedding = JSON.parse(row.embedding);
+      const score = cosineSimilarity(embedding, storedEmbedding);
+      return {
+        summary: {
+          id: row.summary_id,
+          content: row.content,
+          timestamp: row.timestamp,
+          messageRange: { from: row.message_range_from, to: row.message_range_to }
+        },
+        score
+      };
+    });
+    return scored.sort((a, b) => b.score - a.score).slice(0, limit).map((entry) => entry.summary);
+  }
   close() {
     this.db.close();
   }
 };
 
+// src/store/postgres.ts
+import { createRequire as createRequire2 } from "module";
+var require3 = createRequire2(import.meta.url);
+var SCHEMA_SQL = `
+CREATE EXTENSION IF NOT EXISTS vector;
+
+CREATE TABLE IF NOT EXISTS agent_messages (
+  id SERIAL PRIMARY KEY,
+  agent_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  content TEXT NOT NULL,
+  timestamp BIGINT NOT NULL,
+  tool_calls JSONB,
+  tool_call_id TEXT
+);
+
+CREATE TABLE IF NOT EXISTS agent_summaries (
+  id TEXT PRIMARY KEY,
+  agent_id TEXT NOT NULL,
+  content TEXT NOT NULL,
+  timestamp BIGINT NOT NULL,
+  message_range_from BIGINT NOT NULL,
+  message_range_to BIGINT NOT NULL,
+  embedding vector(768)
+);
+
+CREATE INDEX IF NOT EXISTS idx_agent_messages_agent ON agent_messages(agent_id);
+CREATE INDEX IF NOT EXISTS idx_agent_summaries_agent ON agent_summaries(agent_id);
+`;
+var PostgresStore = class _PostgresStore {
+  pool;
+  constructor(config) {
+    const { Pool } = require3("pg");
+    this.pool = new Pool({ connectionString: config.connectionString });
+    void this.init();
+  }
+  async init() {
+    await this.pool.query(SCHEMA_SQL);
+  }
+  /** Factory that ensures schema is ready before returning the store. */
+  static async create(config) {
+    const store = new _PostgresStore(config);
+    await store.init();
+    return store;
+  }
+  async saveMessages(agentId, messages) {
+    for (const msg of messages) {
+      await this.pool.query(
+        `INSERT INTO agent_messages (agent_id, role, content, timestamp, tool_calls, tool_call_id)
+         VALUES ($1, $2, $3, $4, $5, $6)`,
+        [
+          agentId,
+          msg.role,
+          msg.content,
+          msg.timestamp,
+          msg.toolCalls ? JSON.stringify(msg.toolCalls) : null,
+          msg.toolCallId ?? null
+        ]
+      );
+    }
+  }
+  async getRecentMessages(agentId, limit) {
+    const result = await this.pool.query(
+      `SELECT role, content, timestamp, tool_calls, tool_call_id
+       FROM agent_messages
+       WHERE agent_id = $1
+       ORDER BY id DESC
+       LIMIT $2`,
+      [agentId, limit]
+    );
+    return result.rows.reverse().map((row) => ({
+      role: row.role,
+      content: row.content,
+      timestamp: Number(row.timestamp),
+      ...row.tool_calls ? {
+        toolCalls: typeof row.tool_calls === "string" ? JSON.parse(row.tool_calls) : row.tool_calls
+      } : {},
+      ...row.tool_call_id ? { toolCallId: row.tool_call_id } : {}
+    }));
+  }
+  async saveSummary(agentId, summary) {
+    await this.pool.query(
+      `INSERT INTO agent_summaries (id, agent_id, content, timestamp, message_range_from, message_range_to)
+       VALUES ($1, $2, $3, $4, $5, $6)`,
+      [
+        summary.id,
+        agentId,
+        summary.content,
+        summary.timestamp,
+        summary.messageRange.from,
+        summary.messageRange.to
+      ]
+    );
+  }
+  async searchSummaries(agentId, query, limit) {
+    const result = await this.pool.query(
+      `SELECT id, content, timestamp, message_range_from, message_range_to
+       FROM agent_summaries
+       WHERE agent_id = $1 AND content ILIKE $2
+       ORDER BY timestamp DESC
+       LIMIT $3`,
+      [agentId, `%${query}%`, limit]
+    );
+    return result.rows.map((row) => ({
+      id: row.id,
+      content: row.content,
+      timestamp: Number(row.timestamp),
+      messageRange: {
+        from: Number(row.message_range_from),
+        to: Number(row.message_range_to)
+      }
+    }));
+  }
+  async saveEmbedding(agentId, summaryId, embedding) {
+    const vectorLiteral = `[${embedding.join(",")}]`;
+    await this.pool.query(
+      `UPDATE agent_summaries SET embedding = $1 WHERE id = $2 AND agent_id = $3`,
+      [vectorLiteral, summaryId, agentId]
+    );
+  }
+  async searchByEmbedding(agentId, embedding, limit) {
+    const vectorLiteral = `[${embedding.join(",")}]`;
+    const result = await this.pool.query(
+      `SELECT id, content, timestamp, message_range_from, message_range_to
+       FROM agent_summaries
+       WHERE agent_id = $1 AND embedding IS NOT NULL
+       ORDER BY embedding <=> $2
+       LIMIT $3`,
+      [agentId, vectorLiteral, limit]
+    );
+    return result.rows.map((row) => ({
+      id: row.id,
+      content: row.content,
+      timestamp: Number(row.timestamp),
+      messageRange: {
+        from: Number(row.message_range_from),
+        to: Number(row.message_range_to)
+      }
+    }));
+  }
+  async close() {
+    await this.pool.end();
+  }
+};
+
 // src/memory.ts
 var Memory = class {
   store;
   windowSize;
   summarizeAfter;
   model;
+  embeddingAdapter;
   messageCount = /* @__PURE__ */ new Map();
   constructor(config = {}) {
     this.windowSize = config.windowSize ?? 20;
     this.summarizeAfter = config.summarizeAfter ?? 20;
+    this.embeddingAdapter = config.embedding;
     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 if (config.store === "postgres") {
+      const connectionString = config.url ?? config.path;
+      if (!connectionString) {
+        throw new Error(
+          "Memory store 'postgres' requires a connection string via the 'url' config option."
+        );
+      }
+      this.store = new PostgresStore({ connectionString });
     } else {
       this.store = config.store;
     }
@@ -844,7 +1086,13 @@ var Memory = class {
   }
   async getContext(agentId, query) {
     const recentMessages = await this.store.getRecentMessages(agentId, this.windowSize);
-    const relevantSummaries = await this.store.searchSummaries(agentId, query, 3);
+    let relevantSummaries;
+    if (this.embeddingAdapter && this.store.searchByEmbedding) {
+      const queryEmbedding = await this.embeddingAdapter.embed(query);
+      relevantSummaries = await this.store.searchByEmbedding(agentId, queryEmbedding, 3);
+    } else {
+      relevantSummaries = await this.store.searchSummaries(agentId, query, 3);
+    }
     return { recentMessages, relevantSummaries };
   }
   async summarize(agentId) {
@@ -867,6 +1115,10 @@ var Memory = class {
       }
     });
     await this.store.saveSummary(agentId, summary);
+    if (this.embeddingAdapter && this.store.saveEmbedding) {
+      const embedding = await this.embeddingAdapter.embed(summary.content);
+      await this.store.saveEmbedding(agentId, summary.id, embedding);
+    }
   }
   close() {
     if ("close" in this.store && typeof this.store.close === "function") {
@@ -874,13 +1126,45 @@ var Memory = class {
     }
   }
 };
+
+// src/model/ollama-embedding.ts
+var OllamaEmbeddingAdapter = class {
+  baseURL;
+  model;
+  constructor(config = {}) {
+    this.baseURL = config.baseURL ?? "http://localhost:11434";
+    this.model = config.model ?? "nomic-embed-text";
+  }
+  async embed(text) {
+    const [vector] = await this.request(text);
+    return vector;
+  }
+  async embedBatch(texts) {
+    if (texts.length === 0) return [];
+    return this.request(texts);
+  }
+  async request(input) {
+    const response = await fetch(`${this.baseURL}/api/embed`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: this.model, input })
+    });
+    if (!response.ok) {
+      throw new Error(`Ollama embedding request failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.embeddings;
+  }
+};
 export {
   Agent,
   AgentEventEmitter,
   InMemoryStore,
   Memory,
   MockAdapter,
+  OllamaEmbeddingAdapter,
   OpenAICompatibleAdapter,
+  PostgresStore,
   SQLiteStore,
   Team,
   Tool,