@avee1234/agent-kit 0.1.0 → 0.3.0

package/dist/index.js

@@ -237,6 +237,9 @@ var Agent = class {
   isModelAdapter(obj) {
     return typeof obj.chat === "function";
   }
+  getModel() {
+    return this.model;
+  }
   on(type, handler) {
     this.emitter.on(type, handler);
   }
@@ -392,6 +395,144 @@ var Agent = class {
   }
 };
 
+// src/strategy/sequential.ts
+var SequentialStrategy = class {
+  async execute(agents, task, _options, emitter) {
+    const responses = [];
+    let previousOutput;
+    for (const agent of agents) {
+      const input = previousOutput !== void 0 ? `${task}
+
+Previous agent output:
+${previousOutput}` : task;
+      emitter.emit({
+        type: "team:agent:start",
+        timestamp: Date.now(),
+        agentId: "team",
+        data: { agentName: agent.name, input }
+      });
+      const startTime = Date.now();
+      const result = await agent.chat(input);
+      const latencyMs = Date.now() - startTime;
+      emitter.emit({
+        type: "team:agent:end",
+        timestamp: Date.now(),
+        agentId: "team",
+        data: { agentName: agent.name, output: result.content },
+        latencyMs
+      });
+      responses.push({ agent: agent.name, content: result.content });
+      previousOutput = result.content;
+    }
+    return {
+      content: responses[responses.length - 1]?.content ?? "",
+      responses
+    };
+  }
+};
+
+// src/strategy/parallel.ts
+var ParallelStrategy = class {
+  async execute(agents, task, _options, emitter) {
+    const agentPromises = agents.map(async (agent) => {
+      emitter.emit({
+        type: "team:agent:start",
+        timestamp: Date.now(),
+        agentId: "team",
+        data: { agentName: agent.name, input: task }
+      });
+      const startTime = Date.now();
+      const result = await agent.chat(task);
+      const latencyMs = Date.now() - startTime;
+      emitter.emit({
+        type: "team:agent:end",
+        timestamp: Date.now(),
+        agentId: "team",
+        data: { agentName: agent.name, output: result.content },
+        latencyMs
+      });
+      return { agent: agent.name, content: result.content };
+    });
+    const responses = await Promise.all(agentPromises);
+    const content = responses.map((r) => `[${r.agent}]: ${r.content}`).join("\n\n");
+    return { content, responses };
+  }
+};
+
+// src/strategy/debate.ts
+var DebateStrategy = class {
+  async execute(agents, task, options, emitter) {
+    const maxRounds = options.maxRounds ?? 3;
+    const responses = [];
+    const priorOutputs = [];
+    for (let round = 1; round <= maxRounds; round++) {
+      emitter.emit({
+        type: "team:round",
+        timestamp: Date.now(),
+        agentId: "team",
+        data: { round, totalRounds: maxRounds }
+      });
+      for (const agent of agents) {
+        const context = priorOutputs.length > 0 ? `${task}
+
+Debate so far:
+${priorOutputs.join("\n\n")}
+
+Your turn (Round ${round}):` : `${task}
+
+(Round ${round}):`;
+        emitter.emit({
+          type: "team:agent:start",
+          timestamp: Date.now(),
+          agentId: "team",
+          data: { agentName: agent.name, round }
+        });
+        const startTime = Date.now();
+        const result = await agent.chat(context);
+        const latencyMs = Date.now() - startTime;
+        emitter.emit({
+          type: "team:agent:end",
+          timestamp: Date.now(),
+          agentId: "team",
+          data: { agentName: agent.name, output: result.content, round },
+          latencyMs
+        });
+        const agentResponse = {
+          agent: agent.name,
+          content: result.content,
+          round
+        };
+        responses.push(agentResponse);
+        priorOutputs.push(`[${agent.name}, Round ${round}]: ${result.content}`);
+      }
+    }
+    const firstAgent = agents[0];
+    const synthesisInput = `${task}
+
+Debate summary:
+${priorOutputs.join("\n\n")}
+
+Provide your final answer:`;
+    emitter.emit({
+      type: "team:agent:start",
+      timestamp: Date.now(),
+      agentId: "team",
+      data: { agentName: firstAgent.name, phase: "final" }
+    });
+    const finalResult = await firstAgent.chat(synthesisInput);
+    emitter.emit({
+      type: "team:agent:end",
+      timestamp: Date.now(),
+      agentId: "team",
+      data: { agentName: firstAgent.name, output: finalResult.content, phase: "final" }
+    });
+    return {
+      content: finalResult.content,
+      responses
+    };
+  }
+};
+
 // src/tool.ts
 var Tool = class _Tool {
   name;
@@ -416,10 +557,157 @@ var Tool = class _Tool {
   }
 };
 
+// src/strategy/hierarchical.ts
+var HierarchicalStrategy = class {
+  async execute(agents, task, options, emitter) {
+    const { manager, maxDelegations = 10 } = options;
+    if (!manager) {
+      throw new Error("HierarchicalStrategy requires a manager agent");
+    }
+    const agentMap = new Map(agents.map((a) => [a.name, a]));
+    const responses = [];
+    const delegateTool = Tool.create({
+      name: "delegate",
+      description: "Delegate a sub-task to a specialist agent. Use this to assign work to workers.",
+      parameters: {
+        agentName: {
+          type: "string",
+          description: "The name of the agent to delegate to",
+          required: true
+        },
+        task: {
+          type: "string",
+          description: "The task to assign to the agent",
+          required: true
+        }
+      },
+      execute: async (params) => {
+        const agentName = params.agentName;
+        const subTask = params.task;
+        const worker = agentMap.get(agentName);
+        if (!worker) {
+          return `Error: No agent named "${agentName}" found. Available agents: ${[...agentMap.keys()].join(", ")}`;
+        }
+        emitter.emit({
+          type: "team:delegate",
+          timestamp: Date.now(),
+          agentId: "team",
+          data: { agentName, task: subTask }
+        });
+        const result = await worker.chat(subTask);
+        const response = { agent: agentName, content: result.content };
+        responses.push(response);
+        return result.content;
+      }
+    });
+    const orchestratorAgent = new Agent({
+      name: manager.name,
+      model: manager.getModel(),
+      tools: [delegateTool],
+      system: `You are an orchestrating manager. You have access to specialist agents: ${[...agentMap.keys()].join(", ")}. Use the delegate tool to assign sub-tasks to them.`,
+      maxToolRounds: maxDelegations
+    });
+    const finalResult = await orchestratorAgent.chat(task);
+    return {
+      content: finalResult.content,
+      responses
+    };
+  }
+};
+
+// src/team.ts
+var Team = class {
+  agents;
+  strategyName;
+  manager;
+  maxRounds;
+  maxDelegations;
+  emitter;
+  constructor(config) {
+    this.agents = config.agents;
+    this.strategyName = config.strategy;
+    this.manager = config.manager;
+    this.maxRounds = config.maxRounds;
+    this.maxDelegations = config.maxDelegations;
+    this.emitter = new AgentEventEmitter();
+  }
+  on(type, handler) {
+    this.emitter.on(type, handler);
+  }
+  off(type, handler) {
+    this.emitter.off(type, handler);
+  }
+  async run(task) {
+    this.emitter.emit({
+      type: "team:start",
+      timestamp: Date.now(),
+      agentId: "team",
+      data: {
+        strategy: this.strategyName,
+        agentCount: this.agents.length,
+        task
+      }
+    });
+    const startTime = Date.now();
+    const strategy = this.resolveStrategy();
+    const result = await strategy.execute(
+      this.agents,
+      task,
+      {
+        maxRounds: this.maxRounds,
+        maxDelegations: this.maxDelegations,
+        manager: this.manager
+      },
+      this.emitter
+    );
+    const latencyMs = Date.now() - startTime;
+    this.emitter.emit({
+      type: "team:end",
+      timestamp: Date.now(),
+      agentId: "team",
+      data: {
+        strategy: this.strategyName,
+        responseCount: result.responses.length
+      },
+      latencyMs
+    });
+    return result;
+  }
+  resolveStrategy() {
+    switch (this.strategyName) {
+      case "sequential":
+        return new SequentialStrategy();
+      case "parallel":
+        return new ParallelStrategy();
+      case "debate":
+        return new DebateStrategy();
+      case "hierarchical":
+        return new HierarchicalStrategy();
+    }
+  }
+};
+
+// 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);
@@ -440,6 +728,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
@@ -472,8 +782,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) {
@@ -533,6 +849,34 @@ 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();
   }
@@ -544,10 +888,12 @@ var Memory = class {
   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") {
@@ -573,7 +919,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) {
@@ -596,6 +948,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") {
@@ -603,14 +959,46 @@ 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,
   SQLiteStore,
+  Team,
   Tool,
   createMessage,
   createSummary,