fourmis-agents-sdk 0.3.0 → 0.4.0

package/dist/utils/session-store.js

@@ -1,5 +1,20 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -37,6 +52,13 @@ function mergeUsage(a, b) {
 import { readFileSync, appendFileSync, mkdirSync, readdirSync, statSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
 function sanitizeCwd(cwd) {
   return cwd.replace(/[/.]/g, "-");
 }
@@ -100,7 +122,7 @@ function findLatestSession(cwd) {
     return null;
   }
 }
-function loadSessionMessages(cwd, sessionId) {
+function loadSessionMessages(cwd, sessionId, resumeSessionAt) {
   const dir = sessionsDir(cwd);
   const filePath = join(dir, `${sessionId}.jsonl`);
   let lines;
@@ -111,7 +133,10 @@ function loadSessionMessages(cwd, sessionId) {
     return [];
   }
   const messages = [];
+  let reachedResumePoint = false;
   for (const line of lines) {
+    if (resumeSessionAt && reachedResumePoint)
+      break;
     try {
       const entry = JSON.parse(line);
       if (entry.type !== "user" && entry.type !== "assistant")
@@ -126,11 +151,48 @@ function loadSessionMessages(cwd, sessionId) {
       if (typeof message.content === "string") {
         content = message.content;
       } else if (Array.isArray(message.content)) {
-        content = message.content.filter((c) => c.type === "text" || c.type === "tool_use" || c.type === "tool_result").map((c) => c);
+        const normalizedBlocks = [];
+        for (const c of message.content) {
+          if (!c || typeof c !== "object")
+            continue;
+          const block = c;
+          if (typeof block.type !== "string")
+            continue;
+          if (block.type === "text" && typeof block.text === "string") {
+            normalizedBlocks.push({ type: "text", text: block.text });
+            continue;
+          }
+          if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+            normalizedBlocks.push({
+              type: "tool_use",
+              id: block.id,
+              name: block.name,
+              input: block.input ?? {}
+            });
+            continue;
+          }
+          if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+            normalizedBlocks.push({
+              type: "tool_result",
+              tool_use_id: block.tool_use_id,
+              content: typeof block.content === "string" ? block.content : safeStringify(block.content),
+              is_error: typeof block.is_error === "boolean" ? block.is_error : undefined
+            });
+            continue;
+          }
+          normalizedBlocks.push({
+            type: "text",
+            text: `[session:${block.type}] ${safeStringify(block)}`
+          });
+        }
+        content = normalizedBlocks;
       } else {
         continue;
       }
       messages.push({ role, content });
+      if (resumeSessionAt && entry.uuid === resumeSessionAt) {
+        reachedResumePoint = true;
+      }
     } catch {}
   }
   return messages;

package/dist/utils/system-prompt.d.ts

@@ -1,11 +1,15 @@
 /**
  * System prompt builder — assembles the system prompt that makes the agent effective.
  */
+import type { Skill } from "../skills/index.js";
 export type SystemPromptContext = {
     tools: string[];
     cwd?: string;
+    additionalDirectories?: string[];
+    loadProjectInstructions?: boolean;
     permissionMode?: string;
     customPrompt?: string;
+    skills?: Skill[];
 };
 export declare function buildSystemPrompt(context: SystemPromptContext): string;
 //# sourceMappingURL=system-prompt.d.ts.map

package/dist/utils/system-prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-prompt.d.ts","sourceRoot":"","sources":["../../src/utils/system-prompt.ts"],"names":[],"mappings":"AAAA;;GAEG;AA+DH,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CA8BtE"}
+{"version":3,"file":"system-prompt.d.ts","sourceRoot":"","sources":["../../src/utils/system-prompt.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AA6DhD,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;CAClB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CA8CtE"}

package/dist/utils/system-prompt.js

@@ -1,5 +1,20 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -12,9 +27,299 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/skills/frontmatter.ts
+import { parse } from "yaml";
+function normalizeNewlines(value) {
+  return value.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+}
+function extractFrontmatter(content) {
+  const normalized = normalizeNewlines(content);
+  if (!normalized.startsWith("---")) {
+    return { yamlString: null, body: normalized };
+  }
+  const endIndex = normalized.indexOf(`
+---`, 3);
+  if (endIndex === -1) {
+    return { yamlString: null, body: normalized };
+  }
+  return {
+    yamlString: normalized.slice(4, endIndex),
+    body: normalized.slice(endIndex + 4).trim()
+  };
+}
+function parseFrontmatter(content) {
+  const { yamlString, body } = extractFrontmatter(content);
+  if (!yamlString) {
+    return { frontmatter: {}, body };
+  }
+  const parsed = parse(yamlString);
+  return { frontmatter: parsed ?? {}, body };
+}
+function stripFrontmatter(content) {
+  return parseFrontmatter(content).body;
+}
+
+// src/skills/skills.ts
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname, isAbsolute, join, resolve } from "path";
+var MAX_NAME_LENGTH = 64;
+var MAX_DESCRIPTION_LENGTH = 1024;
+var MAX_COMPATIBILITY_LENGTH = 500;
+var CONFIG_DIR_NAME = ".claude";
+function shouldIgnore(name) {
+  return name.startsWith(".") || name === "node_modules";
+}
+function validateName(name, parentDirName) {
+  const errors = [];
+  if (name !== parentDirName) {
+    errors.push(`name "${name}" does not match parent directory "${parentDirName}"`);
+  }
+  if (name.length > MAX_NAME_LENGTH) {
+    errors.push(`name exceeds ${MAX_NAME_LENGTH} characters (${name.length})`);
+  }
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    errors.push(`name contains invalid characters (must be lowercase a-z, 0-9, hyphens only)`);
+  }
+  if (name.startsWith("-") || name.endsWith("-")) {
+    errors.push(`name must not start or end with a hyphen`);
+  }
+  if (name.includes("--")) {
+    errors.push(`name must not contain consecutive hyphens`);
+  }
+  return errors;
+}
+function validateDescription(description) {
+  const errors = [];
+  if (!description || description.trim() === "") {
+    errors.push("description is required");
+  } else if (description.length > MAX_DESCRIPTION_LENGTH) {
+    errors.push(`description exceeds ${MAX_DESCRIPTION_LENGTH} characters (${description.length})`);
+  }
+  return errors;
+}
+function validateCompatibility(compatibility) {
+  if (!compatibility)
+    return [];
+  if (compatibility.length > MAX_COMPATIBILITY_LENGTH) {
+    return [`compatibility exceeds ${MAX_COMPATIBILITY_LENGTH} characters (${compatibility.length})`];
+  }
+  return [];
+}
+function loadSkillsFromDir(options) {
+  return loadSkillsFromDirInternal(options.dir, options.source, true);
+}
+function loadSkillsFromDirInternal(dir, source, includeRootFiles) {
+  const skills = [];
+  const diagnostics = [];
+  if (!existsSync(dir)) {
+    return { skills, diagnostics };
+  }
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (shouldIgnore(entry.name)) {
+        continue;
+      }
+      const fullPath = join(dir, entry.name);
+      let isDirectory = entry.isDirectory();
+      let isFile = entry.isFile();
+      if (entry.isSymbolicLink()) {
+        try {
+          const stats = statSync(fullPath);
+          isDirectory = stats.isDirectory();
+          isFile = stats.isFile();
+        } catch {
+          continue;
+        }
+      }
+      if (isDirectory) {
+        const subResult = loadSkillsFromDirInternal(fullPath, source, false);
+        skills.push(...subResult.skills);
+        diagnostics.push(...subResult.diagnostics);
+        continue;
+      }
+      if (!isFile)
+        continue;
+      const isRootMd = includeRootFiles && entry.name.endsWith(".md");
+      const isSkillMd = !includeRootFiles && entry.name === "SKILL.md";
+      if (!isRootMd && !isSkillMd)
+        continue;
+      const result = loadSkillFromFile(fullPath, source);
+      if (result.skill) {
+        skills.push(result.skill);
+      }
+      diagnostics.push(...result.diagnostics);
+    }
+  } catch {}
+  return { skills, diagnostics };
+}
+function loadSkillFromFile(filePath, source) {
+  const diagnostics = [];
+  try {
+    const rawContent = readFileSync(filePath, "utf-8");
+    const { frontmatter } = parseFrontmatter(rawContent);
+    const skillDir = dirname(filePath);
+    const parentDirName = basename(skillDir);
+    const descErrors = validateDescription(frontmatter.description);
+    for (const error of descErrors) {
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    const name = frontmatter.name || parentDirName;
+    const nameErrors = validateName(name, parentDirName);
+    for (const error of nameErrors) {
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    const compatErrors = validateCompatibility(frontmatter.compatibility);
+    for (const error of compatErrors) {
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    if (!frontmatter.description || frontmatter.description.trim() === "") {
+      return { skill: null, diagnostics };
+    }
+    const allowedToolsRaw = frontmatter["allowed-tools"];
+    const allowedTools = allowedToolsRaw ? allowedToolsRaw.split(/\s+/).filter(Boolean) : undefined;
+    return {
+      skill: {
+        name,
+        description: frontmatter.description,
+        filePath,
+        baseDir: skillDir,
+        source,
+        disableModelInvocation: frontmatter["disable-model-invocation"] === true,
+        license: frontmatter.license,
+        compatibility: frontmatter.compatibility,
+        metadata: frontmatter.metadata,
+        allowedTools
+      },
+      diagnostics
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "failed to parse skill file";
+    diagnostics.push({ type: "warning", message, path: filePath });
+    return { skill: null, diagnostics };
+  }
+}
+function normalizePath(input) {
+  const trimmed = input.trim();
+  if (trimmed === "~")
+    return homedir();
+  if (trimmed.startsWith("~/"))
+    return join(homedir(), trimmed.slice(2));
+  if (trimmed.startsWith("~"))
+    return join(homedir(), trimmed.slice(1));
+  return trimmed;
+}
+function resolveSkillPath(p, cwd) {
+  const normalized = normalizePath(p);
+  return isAbsolute(normalized) ? normalized : resolve(cwd, normalized);
+}
+function loadSkills(options = {}) {
+  const { cwd = process.cwd(), skillPaths = [], includeDefaults = true } = options;
+  const skillMap = new Map;
+  const realPathSet = new Set;
+  const allDiagnostics = [];
+  const collisionDiagnostics = [];
+  function addSkills(result) {
+    allDiagnostics.push(...result.diagnostics);
+    for (const skill of result.skills) {
+      let realPath;
+      try {
+        realPath = realpathSync(skill.filePath);
+      } catch {
+        realPath = skill.filePath;
+      }
+      if (realPathSet.has(realPath))
+        continue;
+      const existing = skillMap.get(skill.name);
+      if (existing) {
+        collisionDiagnostics.push({
+          type: "collision",
+          message: `name "${skill.name}" collision`,
+          path: skill.filePath,
+          collision: {
+            resourceType: "skill",
+            name: skill.name,
+            winnerPath: existing.filePath,
+            loserPath: skill.filePath
+          }
+        });
+      } else {
+        skillMap.set(skill.name, skill);
+        realPathSet.add(realPath);
+      }
+    }
+  }
+  if (includeDefaults) {
+    const userSkillsDir = join(homedir(), CONFIG_DIR_NAME, "skills");
+    const projectSkillsDir = resolve(cwd, CONFIG_DIR_NAME, "skills");
+    addSkills(loadSkillsFromDirInternal(userSkillsDir, "user", true));
+    addSkills(loadSkillsFromDirInternal(projectSkillsDir, "project", true));
+  }
+  for (const rawPath of skillPaths) {
+    const resolvedPath = resolveSkillPath(rawPath, cwd);
+    if (!existsSync(resolvedPath)) {
+      allDiagnostics.push({ type: "warning", message: "skill path does not exist", path: resolvedPath });
+      continue;
+    }
+    try {
+      const stats = statSync(resolvedPath);
+      if (stats.isDirectory()) {
+        addSkills(loadSkillsFromDirInternal(resolvedPath, "path", true));
+      } else if (stats.isFile() && resolvedPath.endsWith(".md")) {
+        const result = loadSkillFromFile(resolvedPath, "path");
+        if (result.skill) {
+          addSkills({ skills: [result.skill], diagnostics: result.diagnostics });
+        } else {
+          allDiagnostics.push(...result.diagnostics);
+        }
+      } else {
+        allDiagnostics.push({ type: "warning", message: "skill path is not a markdown file", path: resolvedPath });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "failed to read skill path";
+      allDiagnostics.push({ type: "warning", message, path: resolvedPath });
+    }
+  }
+  return {
+    skills: Array.from(skillMap.values()),
+    diagnostics: [...allDiagnostics, ...collisionDiagnostics]
+  };
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function formatSkillsForPrompt(skills) {
+  const visibleSkills = skills.filter((s) => !s.disableModelInvocation);
+  if (visibleSkills.length === 0) {
+    return "";
+  }
+  const lines = [
+    "The following skills provide specialized instructions for specific tasks.",
+    "Use the read tool to load a skill's file when the task matches its description.",
+    "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
+    "",
+    "<available_skills>"
+  ];
+  for (const skill of visibleSkills) {
+    lines.push("  <skill>");
+    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+    if (skill.allowedTools?.length) {
+      lines.push(`    <allowed-tools>${escapeXml(skill.allowedTools.join(" "))}</allowed-tools>`);
+    }
+    lines.push("  </skill>");
+  }
+  lines.push("</available_skills>");
+  return lines.join(`
+`);
+}
 // src/utils/system-prompt.ts
-import { readFileSync } from "fs";
-import { join } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
 var CORE_IDENTITY = `You are an AI coding agent. You help users with software engineering tasks by reading, writing, and modifying code. You have access to tools that let you interact with the filesystem and execute commands.
 
 You are highly capable and can help users complete complex tasks that would otherwise be too difficult or time-consuming.`;
@@ -78,11 +383,26 @@ function buildSystemPrompt(context) {
     sections.push(`# Environment
 
 Working directory: ${context.cwd}`);
-    const instructions = readProjectInstructions(context.cwd);
-    if (instructions) {
-      sections.push(`# Project Instructions
+    if (context.additionalDirectories && context.additionalDirectories.length > 0) {
+      sections.push(`Additional allowed directories:
+${context.additionalDirectories.map((d) => `- ${d}`).join(`
+`)}`);
+    }
+    if (context.loadProjectInstructions) {
+      const instructions = readProjectInstructions(context.cwd);
+      if (instructions) {
+        sections.push(`# Project Instructions
 
 ${instructions}`);
+      }
+    }
+  }
+  if (context.skills && context.skills.length > 0) {
+    const skillsPrompt = formatSkillsForPrompt(context.skills);
+    if (skillsPrompt) {
+      sections.push(`# Skills
+
+${skillsPrompt}`);
     }
   }
   if (context.customPrompt) {
@@ -95,7 +415,7 @@ ${instructions}`);
 function readProjectInstructions(cwd) {
   for (const name of ["CLAUDE.md", "AGENTS.md"]) {
     try {
-      const content = readFileSync(join(cwd, name), "utf-8").trim();
+      const content = readFileSync2(join2(cwd, name), "utf-8").trim();
       if (content)
         return content;
     } catch {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fourmis-agents-sdk",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Multi-provider AI agent SDK with direct API access and in-process tool execution",
   "type": "module",
   "main": "dist/index.js",
@@ -58,13 +58,15 @@
     "typecheck": "tsc --noEmit",
     "test": "bun test",
     "test:tools": "bun test tests/tools/",
-    "test:integration": "bun test tests/integration.test.ts"
+    "test:integration": "bun test tests/integration.test.ts",
+    "test:compat": "bun run tests/compat/run-compat.ts"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.74.0",
     "@google/genai": "^1.40.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "openai": "^6.21.0",
+    "yaml": "^2.8.2",
     "zod": "^3.24.0"
   },
   "devDependencies": {