fourmis-agents-sdk 0.1.0

package/dist/agent-loop.js

@@ -0,0 +1,387 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/tools/mcp-resources.ts
+var exports_mcp_resources = {};
+__export(exports_mcp_resources, {
+  createReadMcpResourceTool: () => createReadMcpResourceTool,
+  createListMcpResourcesTool: () => createListMcpResourcesTool
+});
+function createListMcpResourcesTool(mcpClient) {
+  return {
+    name: "mcp__list_resources",
+    description: "List available resources from MCP servers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Optional server name to filter by. If omitted, lists resources from all servers."
+        }
+      }
+    },
+    async execute(input) {
+      const { server } = input ?? {};
+      try {
+        const resources = await mcpClient.listResources(server);
+        if (resources.length === 0) {
+          return { content: "No resources available." };
+        }
+        const lines = resources.map((r) => `[${r.server}] ${r.uri} - ${r.name}${r.description ? `: ${r.description}` : ""}`);
+        return { content: lines.join(`
+`) };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `Error listing resources: ${message}`, isError: true };
+      }
+    }
+  };
+}
+function createReadMcpResourceTool(mcpClient) {
+  return {
+    name: "mcp__read_resource",
+    description: "Read a specific resource from an MCP server by URI.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "The MCP server name that hosts the resource."
+        },
+        uri: {
+          type: "string",
+          description: "The resource URI to read."
+        }
+      },
+      required: ["server", "uri"]
+    },
+    async execute(input) {
+      const { server, uri } = input;
+      if (!server || !uri) {
+        return { content: "Both 'server' and 'uri' are required.", isError: true };
+      }
+      try {
+        const content = await mcpClient.readResource(server, uri);
+        return { content };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `Error reading resource: ${message}`, isError: true };
+      }
+    }
+  };
+}
+
+// src/types.ts
+function uuid() {
+  return crypto.randomUUID();
+}
+function emptyTokenUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0
+  };
+}
+function mergeUsage(a, b) {
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    cacheReadInputTokens: a.cacheReadInputTokens + b.cacheReadInputTokens,
+    cacheCreationInputTokens: a.cacheCreationInputTokens + b.cacheCreationInputTokens
+  };
+}
+
+// src/agent-loop.ts
+async function* agentLoop(prompt, options) {
+  const {
+    provider,
+    model,
+    systemPrompt,
+    tools,
+    permissions,
+    cwd,
+    sessionId,
+    maxTurns,
+    maxBudgetUsd,
+    includeStreamEvents,
+    signal,
+    env,
+    debug,
+    hooks,
+    mcpClient
+  } = options;
+  const startTime = Date.now();
+  let apiTimeMs = 0;
+  let turns = 0;
+  let totalUsage = emptyTokenUsage();
+  let costUsd = 0;
+  const modelUsage = {};
+  if (mcpClient) {
+    await mcpClient.connectAll();
+    for (const tool of mcpClient.getTools()) {
+      tools.register(tool);
+    }
+    const { createListMcpResourcesTool: createListMcpResourcesTool2, createReadMcpResourceTool: createReadMcpResourceTool2 } = await Promise.resolve().then(() => exports_mcp_resources);
+    tools.register(createListMcpResourcesTool2(mcpClient));
+    tools.register(createReadMcpResourceTool2(mcpClient));
+  }
+  const messages = [
+    { role: "user", content: prompt }
+  ];
+  yield {
+    type: "init",
+    sessionId,
+    model,
+    provider: provider.name,
+    tools: tools.list(),
+    cwd,
+    uuid: uuid()
+  };
+  if (hooks) {
+    await hooks.fire("SessionStart", { event: "SessionStart", session_id: sessionId }, undefined, { signal });
+  }
+  while (true) {
+    if (signal.aborted) {
+      yield makeError("error_execution", ["Aborted"], turns, costUsd, sessionId, startTime);
+      return;
+    }
+    if (turns >= maxTurns) {
+      yield makeError("error_max_turns", [`Reached maximum turns (${maxTurns})`], turns, costUsd, sessionId, startTime);
+      return;
+    }
+    if (maxBudgetUsd > 0 && costUsd >= maxBudgetUsd) {
+      yield makeError("error_max_budget", [`Reached budget limit ($${maxBudgetUsd})`], turns, costUsd, sessionId, startTime);
+      return;
+    }
+    const toolDefs = tools.getDefinitions();
+    const apiStart = Date.now();
+    let assistantTextParts = [];
+    let toolCalls = [];
+    let turnUsage = emptyTokenUsage();
+    try {
+      const chunks = provider.chat({
+        model,
+        messages,
+        tools: toolDefs.length > 0 ? toolDefs : undefined,
+        systemPrompt,
+        signal
+      });
+      for await (const chunk of chunks) {
+        switch (chunk.type) {
+          case "text_delta":
+            assistantTextParts.push(chunk.text);
+            if (includeStreamEvents) {
+              yield { type: "stream", subtype: "text_delta", text: chunk.text, uuid: uuid() };
+            }
+            break;
+          case "thinking_delta":
+            if (includeStreamEvents) {
+              yield { type: "stream", subtype: "thinking_delta", text: chunk.text, uuid: uuid() };
+            }
+            break;
+          case "tool_call":
+            toolCalls.push({ id: chunk.id, name: chunk.name, input: chunk.input });
+            break;
+          case "usage":
+            turnUsage = mergeUsage(turnUsage, chunk.usage);
+            break;
+          case "done":
+            break;
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      yield makeError("error_execution", [`API error: ${message}`], turns, costUsd, sessionId, startTime);
+      return;
+    }
+    apiTimeMs += Date.now() - apiStart;
+    turns++;
+    totalUsage = mergeUsage(totalUsage, turnUsage);
+    const turnCost = provider.calculateCost(model, turnUsage);
+    costUsd += turnCost;
+    if (!modelUsage[model]) {
+      modelUsage[model] = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        totalCostUsd: 0
+      };
+    }
+    modelUsage[model].inputTokens += turnUsage.inputTokens;
+    modelUsage[model].outputTokens += turnUsage.outputTokens;
+    modelUsage[model].cacheReadInputTokens += turnUsage.cacheReadInputTokens;
+    modelUsage[model].cacheCreationInputTokens += turnUsage.cacheCreationInputTokens;
+    modelUsage[model].totalCostUsd += turnCost;
+    const assistantText = assistantTextParts.join("");
+    const assistantContent = [];
+    if (assistantText) {
+      assistantContent.push({ type: "text", text: assistantText });
+    }
+    for (const call of toolCalls) {
+      assistantContent.push({
+        type: "tool_use",
+        id: call.id,
+        name: call.name,
+        input: call.input
+      });
+    }
+    messages.push({ role: "assistant", content: assistantContent });
+    if (assistantText) {
+      yield { type: "text", text: assistantText, uuid: uuid() };
+    }
+    if (toolCalls.length === 0) {
+      if (hooks) {
+        await hooks.fire("Stop", { event: "Stop", session_id: sessionId, text: assistantText || undefined }, undefined, { signal });
+      }
+      if (hooks) {
+        await hooks.fire("SessionEnd", { event: "SessionEnd", session_id: sessionId }, undefined, { signal });
+      }
+      yield {
+        type: "result",
+        subtype: "success",
+        text: assistantText || null,
+        turns,
+        costUsd,
+        durationMs: Date.now() - startTime,
+        durationApiMs: apiTimeMs,
+        sessionId,
+        usage: totalUsage,
+        modelUsage,
+        uuid: uuid()
+      };
+      return;
+    }
+    const toolResults = [];
+    for (const call of toolCalls) {
+      let hookDenied = false;
+      let hookUpdatedInput;
+      if (hooks) {
+        const hookResult = await hooks.fire("PreToolUse", { event: "PreToolUse", tool_name: call.name, tool_input: call.input, session_id: sessionId }, call.id, { signal });
+        if (hookResult) {
+          if (hookResult.permissionDecision === "deny") {
+            hookDenied = true;
+          }
+          if (hookResult.updatedInput !== undefined) {
+            hookUpdatedInput = hookResult.updatedInput;
+          }
+        }
+      }
+      if (hookDenied) {
+        const denyContent = "Denied by hook";
+        yield {
+          type: "tool_result",
+          id: call.id,
+          name: call.name,
+          content: denyContent,
+          isError: true,
+          uuid: uuid()
+        };
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: call.id,
+          content: denyContent,
+          is_error: true
+        });
+        if (hooks) {
+          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: denyContent, tool_error: true, session_id: sessionId }, call.id, { signal });
+        }
+        continue;
+      }
+      const inputAfterHook = hookUpdatedInput !== undefined ? hookUpdatedInput : call.input;
+      const permResult = await permissions.check(call.name, inputAfterHook ?? {}, { signal, toolUseId: call.id });
+      if (permResult.behavior === "deny") {
+        const denyContent = `Permission denied: ${permResult.message}`;
+        yield {
+          type: "tool_result",
+          id: call.id,
+          name: call.name,
+          content: denyContent,
+          isError: true,
+          uuid: uuid()
+        };
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: call.id,
+          content: denyContent,
+          is_error: true
+        });
+        if (hooks) {
+          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: denyContent, tool_error: true, session_id: sessionId }, call.id, { signal });
+        }
+        continue;
+      }
+      const toolInput = permResult.behavior === "allow" && permResult.updatedInput ? permResult.updatedInput : inputAfterHook;
+      yield {
+        type: "tool_use",
+        id: call.id,
+        name: call.name,
+        input: toolInput,
+        uuid: uuid()
+      };
+      const toolCtx = {
+        cwd,
+        signal,
+        sessionId,
+        env
+      };
+      const result = await tools.execute(call.name, toolInput, toolCtx);
+      if (debug) {
+        console.error(`[debug] Tool ${call.name}: ${result.isError ? "ERROR" : "OK"} (${result.content.length} chars)`);
+      }
+      if (hooks) {
+        if (result.isError) {
+          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: result.content, tool_error: true, session_id: sessionId }, call.id, { signal });
+        } else {
+          const postResult = await hooks.fire("PostToolUse", { event: "PostToolUse", tool_name: call.name, tool_result: result.content, session_id: sessionId }, call.id, { signal });
+          if (postResult?.additionalContext) {
+            result.content += `
+${postResult.additionalContext}`;
+          }
+        }
+      }
+      yield {
+        type: "tool_result",
+        id: call.id,
+        name: call.name,
+        content: result.content,
+        isError: result.isError,
+        uuid: uuid()
+      };
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: call.id,
+        content: result.content,
+        is_error: result.isError
+      });
+    }
+    messages.push({ role: "user", content: toolResults });
+  }
+}
+function makeError(subtype, errors, turns, costUsd, sessionId, startTime) {
+  return {
+    type: "result",
+    subtype,
+    errors,
+    turns,
+    costUsd,
+    durationMs: Date.now() - startTime,
+    sessionId,
+    uuid: uuid()
+  };
+}
+export {
+  agentLoop
+};

package/dist/agents/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Agents module — re-exports.
+ */
+export type { AgentDefinition, BackgroundTask } from "./types.js";
+export { TaskManager } from "./task-manager.js";
+export { createTaskTool, createTaskOutputTool, createTaskStopTool } from "./tools.js";
+export type { AgentContext } from "./tools.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/agents/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACtF,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}