@abassey/aid 0.1.0

package/dist/agents/index.js

@@ -0,0 +1,741 @@
+import {
+  ai,
+  executeToolLoop
+} from "../chunk-YNIEOBDF.js";
+import {
+  AidError
+} from "../chunk-2TNYBUNK.js";
+
+// src/tools/tool.ts
+function isRichParam(value) {
+  return typeof value === "object" && value !== null && "description" in value;
+}
+function paramsToJsonSchema(params) {
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value === "string") {
+      properties[key] = { type: "string", description: value };
+      required.push(key);
+    } else if (isRichParam(value)) {
+      const prop = {
+        type: value.type ?? "string",
+        description: value.description
+      };
+      if (value.enum) {
+        prop.enum = value.enum;
+      }
+      properties[key] = prop;
+      if (!value.optional) {
+        required.push(key);
+      }
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    required
+  };
+}
+function tool(name, description, params, handler) {
+  return {
+    name,
+    description,
+    parameters: paramsToJsonSchema(params),
+    handler
+  };
+}
+
+// src/agents/events.ts
+var AgentEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, cb) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(cb);
+  }
+  off(event, cb) {
+    this.listeners.get(event)?.delete(cb);
+  }
+  emit(event, payload) {
+    const cbs = this.listeners.get(event);
+    if (cbs) {
+      for (const cb of cbs) {
+        cb(payload);
+      }
+    }
+  }
+};
+
+// src/agents/memory.ts
+var InMemoryProvider = class {
+  messages = [];
+  maxMessages;
+  constructor(options) {
+    this.maxMessages = options?.maxMessages ?? 50;
+  }
+  async add(messages) {
+    this.messages.push(...messages);
+    if (this.messages.length > this.maxMessages) {
+      this.messages = this.messages.slice(-this.maxMessages);
+    }
+  }
+  async retrieve(_query, limit) {
+    if (limit !== void 0) {
+      return this.messages.slice(-limit);
+    }
+    return [...this.messages];
+  }
+  async clear() {
+    this.messages = [];
+  }
+};
+
+// src/agents/agent.ts
+var AgentImpl = class _AgentImpl {
+  name;
+  config;
+  emitter = new AgentEventEmitter();
+  memory;
+  chatHistory = [];
+  chatInitialized = false;
+  aiFn;
+  constructor(config) {
+    this.name = config.name;
+    this.config = config;
+    this.aiFn = config.ai ?? ai;
+    if (config.memory === true) {
+      this.memory = new InMemoryProvider();
+    } else if (config.memory && typeof config.memory !== "boolean") {
+      this.memory = config.memory;
+    } else {
+      this.memory = null;
+    }
+  }
+  /**
+   * Core execution method. Makes an initial LLM call via aiFn WITHOUT tools
+   * (to prevent aiCall's internal tool loop), then runs executeToolLoop directly
+   * when the LLM requests tool use.
+   */
+  async executeWithToolLoop(messages) {
+    const tools = this.config.tools ?? [];
+    const maxIterations = this.config.maxIterations ?? 25;
+    const steps = [];
+    let stepCount = 0;
+    this.emitter.emit("step:start", { step: stepCount, iteration: 0 });
+    const initialResponse = await this.aiFn("", {
+      model: this.config.model,
+      system: this.config.role,
+      middleware: this.config.middleware,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      _messages: messages
+      // NO tools — prevents aiCall's tool loop
+    });
+    steps.push({
+      type: "llm_call",
+      iteration: 0,
+      timestamp: Date.now(),
+      data: {
+        model: initialResponse.model,
+        tokens: initialResponse.tokens,
+        finishReason: initialResponse.finishReason
+      },
+      durationMs: initialResponse.latencyMs
+    });
+    this.emitter.emit("step:end", { step: stepCount, iteration: 0, result: initialResponse });
+    stepCount++;
+    if (tools.length === 0 || initialResponse.finishReason !== "tool_use" || !initialResponse.toolCalls || initialResponse.toolCalls.length === 0) {
+      return {
+        response: initialResponse,
+        allMessages: messages,
+        toolCalls: [],
+        steps,
+        iterations: 0
+      };
+    }
+    const callFn = async (request2) => {
+      return this.aiFn("", {
+        model: this.config.model,
+        system: this.config.role,
+        middleware: this.config.middleware,
+        temperature: this.config.temperature,
+        maxTokens: this.config.maxTokens,
+        _messages: request2.messages
+        // NO tools — just LLM transport
+      });
+    };
+    const request = {
+      model: initialResponse.model,
+      messages,
+      options: {
+        model: initialResponse.model,
+        temperature: this.config.temperature ?? 1,
+        maxTokens: this.config.maxTokens ?? 4096,
+        topP: 1,
+        stop: [],
+        timeout: 3e4,
+        tools,
+        middleware: this.config.middleware ?? []
+      },
+      tools: tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }))
+    };
+    const loopResult = await executeToolLoop({
+      call: callFn,
+      request,
+      tools,
+      maxIterations,
+      initialResponse,
+      onToolCall: (tc) => {
+        this.emitter.emit("tool:call", { id: tc.id, name: tc.name, args: tc.args });
+        steps.push({
+          type: "tool_call",
+          iteration: stepCount,
+          timestamp: Date.now(),
+          data: { id: tc.id, name: tc.name, args: tc.args, result: "", isError: false },
+          durationMs: 0
+        });
+      },
+      onToolResult: (tc, result, durationMs) => {
+        this.emitter.emit("tool:result", { id: tc.id, name: tc.name, result, durationMs });
+        for (let i = steps.length - 1; i >= 0; i--) {
+          if (steps[i].type === "tool_call") {
+            steps[i].data.result = result;
+            steps[i].durationMs = durationMs;
+            break;
+          }
+        }
+      },
+      onLlmCall: (resp) => {
+        this.emitter.emit("step:start", { step: stepCount, iteration: stepCount });
+        steps.push({
+          type: "llm_call",
+          iteration: stepCount,
+          timestamp: Date.now(),
+          data: {
+            model: resp.model,
+            tokens: resp.tokens,
+            finishReason: resp.finishReason
+          },
+          durationMs: resp.latencyMs
+        });
+        this.emitter.emit("step:end", { step: stepCount, iteration: stepCount, result: resp });
+        stepCount++;
+      }
+    });
+    return {
+      response: loopResult.response,
+      allMessages: loopResult.messages,
+      toolCalls: loopResult.toolCalls,
+      steps,
+      iterations: loopResult.iterations
+    };
+  }
+  async run(task) {
+    const startTime = Date.now();
+    let memoryMessages = [];
+    if (this.memory) {
+      memoryMessages = await this.memory.retrieve(task);
+    }
+    const messages = [
+      ...memoryMessages,
+      { role: "user", content: task }
+    ];
+    this.emitter.emit("message", { role: "user", content: task });
+    let completed = true;
+    let error;
+    let execResult;
+    try {
+      execResult = await this.executeWithToolLoop(messages);
+    } catch (err) {
+      if (err instanceof AidError && err.code === "tool_loop_limit") {
+        completed = false;
+        error = new AidError("agent_loop_limit", `Agent '${this.name}' hit iteration limit`);
+        execResult = {
+          response: {
+            text: "",
+            model: this.config.model ?? "unknown",
+            tokens: { input: 0, output: 0, total: 0 },
+            cost: 0,
+            latencyMs: Date.now() - startTime,
+            finishReason: "error",
+            raw: err
+          },
+          allMessages: messages,
+          toolCalls: [],
+          steps: [],
+          iterations: 0
+        };
+      } else {
+        throw err;
+      }
+    }
+    const resultMessages = [
+      { role: "system", content: this.config.role },
+      ...execResult.allMessages
+    ];
+    if (this.memory) {
+      await this.memory.add([
+        { role: "user", content: task },
+        { role: "assistant", content: execResult.response.text }
+      ]);
+    }
+    const result = {
+      text: execResult.response.text,
+      completed,
+      messages: resultMessages,
+      steps: execResult.steps,
+      tokens: execResult.response.tokens,
+      cost: execResult.response.cost,
+      latencyMs: Date.now() - startTime,
+      toolCalls: execResult.toolCalls,
+      error
+    };
+    this.emitter.emit("done", { result });
+    return result;
+  }
+  async chat(message) {
+    const startTime = Date.now();
+    const maxChatHistory = this.config.maxChatHistory ?? 50;
+    if (!this.chatInitialized && this.memory) {
+      const memoryMessages = await this.memory.retrieve(message);
+      this.chatHistory.push(...memoryMessages);
+      this.chatInitialized = true;
+    }
+    this.chatHistory.push({ role: "user", content: message });
+    this.emitter.emit("message", { role: "user", content: message });
+    const execResult = await this.executeWithToolLoop([...this.chatHistory]);
+    this.chatHistory.push({ role: "assistant", content: execResult.response.text });
+    if (this.chatHistory.length > maxChatHistory) {
+      this.chatHistory = this.chatHistory.slice(-maxChatHistory);
+    }
+    if (this.memory) {
+      await this.memory.add([
+        { role: "user", content: message },
+        { role: "assistant", content: execResult.response.text }
+      ]);
+    }
+    const resultMessages = [
+      { role: "system", content: this.config.role },
+      ...this.chatHistory
+    ];
+    const result = {
+      text: execResult.response.text,
+      completed: true,
+      messages: resultMessages,
+      steps: execResult.steps,
+      tokens: execResult.response.tokens,
+      cost: execResult.response.cost,
+      latencyMs: Date.now() - startTime,
+      toolCalls: execResult.toolCalls
+    };
+    this.emitter.emit("done", { result });
+    return result;
+  }
+  clone(overrides) {
+    return new _AgentImpl({ ...this.config, ...overrides });
+  }
+  on(event, cb) {
+    this.emitter.on(event, cb);
+  }
+  off(event, cb) {
+    this.emitter.off(event, cb);
+  }
+};
+function agent(config) {
+  return new AgentImpl(config);
+}
+
+// src/agents/crew.ts
+function aggregateTokens(results) {
+  return results.reduce(
+    (acc, r) => ({
+      input: acc.input + r.tokens.input,
+      output: acc.output + r.tokens.output,
+      total: acc.total + r.tokens.total
+    }),
+    { input: 0, output: 0, total: 0 }
+  );
+}
+function aggregateCost(results) {
+  return results.reduce((acc, r) => acc + r.cost, 0);
+}
+function makeErrorResult(agentName, err) {
+  const error = err instanceof AidError ? err : new AidError("provider_error", err instanceof Error ? err.message : String(err));
+  return {
+    text: "",
+    completed: false,
+    messages: [],
+    steps: [],
+    tokens: { input: 0, output: 0, total: 0 },
+    cost: 0,
+    latencyMs: 0,
+    toolCalls: [],
+    error
+  };
+}
+function crew(config) {
+  const emitter = new AgentEventEmitter();
+  const agentMap = /* @__PURE__ */ new Map();
+  for (const a of config.agents) {
+    agentMap.set(a.name, a);
+  }
+  function wireEvents(a) {
+    const events = ["step:start", "step:end", "tool:call", "tool:result", "handoff", "message", "done", "error"];
+    for (const event of events) {
+      a.on(event, (payload) => {
+        emitter.emit(event, { ...payload, agent: a.name });
+      });
+    }
+  }
+  for (const a of config.agents) {
+    wireEvents(a);
+  }
+  async function runSequential(task) {
+    const startTime = Date.now();
+    const agentResults = /* @__PURE__ */ new Map();
+    let previousOutput = "";
+    for (const a of config.agents) {
+      const input = previousOutput ? `Previous agent's output:
+---
+${previousOutput}
+---
+
+Original task: ${task}` : task;
+      const result = await a.run(input);
+      agentResults.set(a.name, result);
+      previousOutput = result.text;
+    }
+    const allResults = [...agentResults.values()];
+    return {
+      text: previousOutput,
+      agentResults,
+      totalTokens: aggregateTokens(allResults),
+      totalCost: aggregateCost(allResults),
+      latencyMs: Date.now() - startTime
+    };
+  }
+  async function runParallel(task) {
+    const startTime = Date.now();
+    const agentResults = /* @__PURE__ */ new Map();
+    const settled = await Promise.allSettled(
+      config.agents.map((a) => a.run(task))
+    );
+    for (let i = 0; i < config.agents.length; i++) {
+      const a = config.agents[i];
+      const s = settled[i];
+      if (s.status === "fulfilled") {
+        agentResults.set(a.name, s.value);
+      } else {
+        agentResults.set(a.name, makeErrorResult(a.name, s.reason));
+      }
+    }
+    const lastAgent = config.agents[config.agents.length - 1];
+    const lastResult = agentResults.get(lastAgent.name);
+    const allResults = [...agentResults.values()];
+    return {
+      text: lastResult.text,
+      agentResults,
+      totalTokens: aggregateTokens(allResults),
+      totalCost: aggregateCost(allResults),
+      latencyMs: Date.now() - startTime
+    };
+  }
+  async function runConditional(task) {
+    const startTime = Date.now();
+    if (config.strategy !== "conditional") throw new Error("unreachable");
+    const targetName = config.router(task);
+    const target = agentMap.get(targetName);
+    if (!target) {
+      throw new AidError("invalid_request", `Unknown agent in crew router: '${targetName}'`);
+    }
+    const result = await target.run(task);
+    const agentResults = /* @__PURE__ */ new Map();
+    agentResults.set(targetName, result);
+    return {
+      text: result.text,
+      agentResults,
+      totalTokens: result.tokens,
+      totalCost: result.cost,
+      latencyMs: Date.now() - startTime
+    };
+  }
+  return {
+    async run(task) {
+      switch (config.strategy) {
+        case "sequential":
+          return runSequential(task);
+        case "parallel":
+          return runParallel(task);
+        case "conditional":
+          return runConditional(task);
+      }
+    },
+    on(event, cb) {
+      emitter.on(event, cb);
+    },
+    off(event, cb) {
+      emitter.off(event, cb);
+    }
+  };
+}
+
+// src/agents/workflow.ts
+function workflow(config) {
+  const emitter = new AgentEventEmitter();
+  const wiredAgents = /* @__PURE__ */ new Set();
+  for (const step of config.steps) {
+    if (!wiredAgents.has(step.agent.name)) {
+      const events = ["step:start", "step:end", "tool:call", "tool:result", "handoff", "message", "done", "error"];
+      for (const event of events) {
+        step.agent.on(event, (payload) => {
+          emitter.emit(event, { ...payload, agent: step.agent.name });
+        });
+      }
+      wiredAgents.add(step.agent.name);
+    }
+  }
+  function getDependencies(step) {
+    if (!step.input) return [];
+    if (typeof step.input === "string") return [step.input];
+    return step.input;
+  }
+  async function run(task) {
+    const startTime = Date.now();
+    const stepResults = /* @__PURE__ */ new Map();
+    const skippedSteps = /* @__PURE__ */ new Set();
+    const failedSteps = /* @__PURE__ */ new Set();
+    const stepMap = /* @__PURE__ */ new Map();
+    for (const step of config.steps) {
+      stepMap.set(step.name, step);
+    }
+    const completed = /* @__PURE__ */ new Set();
+    const pending = new Set(config.steps.map((s) => s.name));
+    while (pending.size > 0) {
+      const ready = [];
+      for (const name of pending) {
+        const step = stepMap.get(name);
+        const deps = getDependencies(step);
+        const allDepsResolved = deps.every(
+          (d) => completed.has(d) || skippedSteps.has(d) || failedSteps.has(d)
+        );
+        if (allDepsResolved) {
+          ready.push(step);
+        }
+      }
+      if (ready.length === 0 && pending.size > 0) {
+        throw new AidError("workflow_error", "Workflow has unresolvable dependencies");
+      }
+      const results = await Promise.allSettled(
+        ready.map(async (step) => {
+          const deps = getDependencies(step);
+          const hasFailedDep = deps.some((d) => failedSteps.has(d));
+          if (hasFailedDep) {
+            failedSteps.add(step.name);
+            pending.delete(step.name);
+            return;
+          }
+          if (step.condition && !step.condition(stepResults)) {
+            skippedSteps.add(step.name);
+            pending.delete(step.name);
+            completed.add(step.name);
+            return;
+          }
+          let input;
+          if (!step.input) {
+            input = task;
+          } else if (typeof step.input === "string") {
+            const depResult = stepResults.get(step.input);
+            input = depResult ? depResult.text : task;
+          } else {
+            const parts = step.input.filter((name) => stepResults.has(name)).map((name) => `[${name} output]:
+${stepResults.get(name).text}`);
+            input = parts.length > 0 ? parts.join("\n\n") : task;
+          }
+          const result = await step.agent.run(input);
+          stepResults.set(step.name, result);
+          pending.delete(step.name);
+          completed.add(step.name);
+        })
+      );
+      for (let i = 0; i < ready.length; i++) {
+        const step = ready[i];
+        const r = results[i];
+        if (r.status === "rejected") {
+          failedSteps.add(step.name);
+          pending.delete(step.name);
+        }
+      }
+      const lastStepName = config.steps[config.steps.length - 1].name;
+      if (failedSteps.has(lastStepName)) {
+        throw new AidError("workflow_error", `Workflow failed: terminal step '${lastStepName}' failed`);
+      }
+      const lastStep = stepMap.get(lastStepName);
+      const lastDeps = getDependencies(lastStep);
+      if (lastDeps.some((d) => failedSteps.has(d)) && !completed.has(lastStepName)) {
+        throw new AidError("workflow_error", `Workflow failed: no path to terminal step '${lastStepName}'`);
+      }
+    }
+    let lastText = "";
+    for (let i = config.steps.length - 1; i >= 0; i--) {
+      const name = config.steps[i].name;
+      if (stepResults.has(name)) {
+        lastText = stepResults.get(name).text;
+        break;
+      }
+    }
+    const allResults = [...stepResults.values()];
+    return {
+      text: lastText,
+      stepResults,
+      totalTokens: allResults.reduce(
+        (acc, r) => ({
+          input: acc.input + r.tokens.input,
+          output: acc.output + r.tokens.output,
+          total: acc.total + r.tokens.total
+        }),
+        { input: 0, output: 0, total: 0 }
+      ),
+      totalCost: allResults.reduce((acc, r) => acc + r.cost, 0),
+      latencyMs: Date.now() - startTime
+    };
+  }
+  return {
+    run,
+    on(event, cb) {
+      emitter.on(event, cb);
+    },
+    off(event, cb) {
+      emitter.off(event, cb);
+    }
+  };
+}
+
+// src/agents/swarm.ts
+var HANDOFF_SENTINEL = "__handoff_signal__";
+function makeHandoffTool(agentNames) {
+  return {
+    name: "__handoff",
+    description: `Transfer this conversation to another agent. Available agents: ${agentNames.join(", ")}`,
+    parameters: {
+      type: "object",
+      properties: {
+        to: { type: "string", description: "Name of the agent to hand off to" },
+        message: { type: "string", description: "Context/reason for the handoff" }
+      },
+      required: ["to", "message"]
+    },
+    handler: async (args) => {
+      return `${HANDOFF_SENTINEL}:${args.to}:${args.message}`;
+    }
+  };
+}
+function swarm(config) {
+  const emitter = new AgentEventEmitter();
+  const maxHandoffs = config.maxHandoffs ?? 10;
+  const agentMap = /* @__PURE__ */ new Map();
+  const agentNames = config.agents.map((a) => a.name);
+  for (const a of config.agents) {
+    agentMap.set(a.name, a);
+  }
+  function wireAgentEvents(a) {
+    const events = ["step:start", "step:end", "tool:call", "tool:result", "message", "done", "error"];
+    for (const event of events) {
+      a.on(event, (payload) => {
+        emitter.emit(event, { ...payload, agent: a.name });
+      });
+    }
+  }
+  async function run(task) {
+    const startTime = Date.now();
+    const handoffChain = [];
+    const agentResults = /* @__PURE__ */ new Map();
+    let handoffCount = 0;
+    const entryAgent = agentMap.get(config.entry);
+    if (!entryAgent) {
+      throw new AidError("handoff_error", `Unknown entry agent: '${config.entry}'`);
+    }
+    let currentAgentName = config.entry;
+    let currentTask = task;
+    const handoffTool = makeHandoffTool(agentNames);
+    while (true) {
+      handoffChain.push(currentAgentName);
+      const currentAgent = agentMap.get(currentAgentName);
+      const agentWithHandoff = currentAgent.clone({
+        tools: [...currentAgent.config.tools ?? [], handoffTool]
+      });
+      wireAgentEvents(agentWithHandoff);
+      const result = await agentWithHandoff.run(currentTask);
+      agentResults.set(currentAgentName, result);
+      let handoffDetected = false;
+      let handoffTo = "";
+      let handoffMessage = "";
+      for (const tc of result.toolCalls) {
+        if (tc.name === "__handoff") {
+          handoffDetected = true;
+          handoffTo = tc.args.to;
+          handoffMessage = tc.args.message;
+          break;
+        }
+      }
+      if (!handoffDetected) {
+        const allResults = [...agentResults.values()];
+        return {
+          text: result.text,
+          handoffChain,
+          agentResults,
+          totalTokens: allResults.reduce(
+            (acc, r) => ({
+              input: acc.input + r.tokens.input,
+              output: acc.output + r.tokens.output,
+              total: acc.total + r.tokens.total
+            }),
+            { input: 0, output: 0, total: 0 }
+          ),
+          totalCost: allResults.reduce((acc, r) => acc + r.cost, 0),
+          latencyMs: Date.now() - startTime
+        };
+      }
+      handoffCount++;
+      if (handoffCount > maxHandoffs) {
+        throw new AidError("handoff_error", `Exceeded maximum handoffs (${maxHandoffs})`);
+      }
+      if (!agentMap.has(handoffTo)) {
+        throw new AidError("handoff_error", `Unknown agent in handoff: '${handoffTo}'`);
+      }
+      emitter.emit("handoff", {
+        from: currentAgentName,
+        to: handoffTo,
+        message: handoffMessage,
+        agent: currentAgentName
+      });
+      currentAgentName = handoffTo;
+      currentTask = `${task}
+
+Context from previous agent (${result.text ? "partial response" : "handoff"}): ${handoffMessage}`;
+    }
+  }
+  return {
+    run,
+    on(event, cb) {
+      emitter.on(event, cb);
+    },
+    off(event, cb) {
+      emitter.off(event, cb);
+    }
+  };
+}
+export {
+  AgentEventEmitter,
+  InMemoryProvider,
+  agent,
+  crew,
+  swarm,
+  tool,
+  workflow
+};