@runfusion/fusion 0.21.0 → 0.23.0

package/dist/plugins/fusion-plugin-hermes-runtime/bundled.js

@@ -0,0 +1,649 @@
+// ../plugin-sdk/dist/index.js
+function definePlugin(plugin2) {
+  return plugin2;
+}
+
+// ../../plugins/fusion-plugin-hermes-runtime/dist/cli-spawn.js
+import { spawn, spawnSync } from "node:child_process";
+import os from "node:os";
+import path, { sep as PATH_SEP } from "node:path";
+var resolvedBinaryCache = /* @__PURE__ */ new Map();
+function resolveBinaryForSpawn(binary) {
+  if (process.platform !== "win32")
+    return binary;
+  if (binary.includes(PATH_SEP) || binary.includes("/") || /\.[a-z]{2,4}$/i.test(binary)) {
+    return binary;
+  }
+  const cached = resolvedBinaryCache.get(binary);
+  if (cached)
+    return cached;
+  try {
+    const result = spawnSync("where", [binary], { encoding: "utf-8" });
+    if (result.status === 0) {
+      const first = (result.stdout ?? "").trim().split(/\r?\n/)[0];
+      if (first?.length) {
+        resolvedBinaryCache.set(binary, first);
+        return first;
+      }
+    }
+  } catch {
+  }
+  return binary;
+}
+var ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+var SESSION_ID_RE = /^session_id:\s+([0-9]{8}_[0-9]{6}_[0-9a-f]{6})\s*$/m;
+var CHROME_LINE_RES = [
+  /^\s*┊\s/,
+  // memory/status sidebar lines
+  /^↻ Resumed session /,
+  // resume banner
+  /^╭─.*╮\s*$/,
+  // top box border
+  /^╰─.*╯\s*$/,
+  // bottom box border
+  /^Query:\s*/
+  // query echo line
+];
+var PROFILE_RULE_RE = /^[\s─]+$/;
+var EM_DASH = "\u2014";
+function parseProfileListOutput(raw) {
+  const lines = raw.replace(ANSI_RE, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  const profiles = [];
+  for (const line of lines) {
+    if (line.trim() === "")
+      continue;
+    if (/^\s*Profile\b/.test(line))
+      continue;
+    if (PROFILE_RULE_RE.test(line))
+      continue;
+    const stripped = line.replace(/^\s+/, "");
+    const columns = stripped.split(/\s{2,}/);
+    const rawName = columns[0] ?? "";
+    const isDefault = rawName.startsWith("\u25C6");
+    const name = rawName.replace(/^◆/, "").trim();
+    if (!name)
+      continue;
+    const toUndef = (v) => v === void 0 || v.trim() === "" || v.trim() === EM_DASH ? void 0 : v.trim();
+    profiles.push({
+      name,
+      model: toUndef(columns[1]),
+      gateway: toUndef(columns[2]),
+      alias: toUndef(columns[3]),
+      isDefault
+    });
+  }
+  return profiles;
+}
+function hermesProfileHome(profileName) {
+  const base = process.env.HERMES_HOME ?? path.join(os.homedir(), ".hermes");
+  if (profileName === "default" || profileName === "")
+    return base;
+  return path.join(base, "profiles", profileName);
+}
+async function listHermesProfiles(opts) {
+  const binary = resolveBinaryForSpawn(opts?.binaryPath ?? "hermes");
+  const timeoutMs = opts?.timeoutMs ?? 5e3;
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const child = spawn(binary, ["profile", "list"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      reject(new Error(`hermes profile list failed: timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("error", (err) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      const isNotFound = err.code === "ENOENT";
+      reject(new Error(isNotFound ? `hermes profile list failed: binary not found at "${opts?.binaryPath ?? "hermes"}"` : `hermes profile list failed: ${err.message}`));
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (code !== 0) {
+        const combined = [stdout, stderr].filter(Boolean).join("\n");
+        reject(new Error(`hermes profile list failed: process exited with code ${String(code)}.
+${combined}`));
+        return;
+      }
+      resolve2(parseProfileListOutput(stdout));
+    });
+  });
+}
+function resolveCliSettings(settings) {
+  const str = (v) => typeof v === "string" && v.trim().length > 0 ? v.trim() : void 0;
+  const num = (v, envKey, fallback) => {
+    if (typeof v === "number" && Number.isFinite(v) && v > 0)
+      return v;
+    const raw = str(v) ?? str(process.env[envKey]);
+    if (raw !== void 0) {
+      const parsed = Number(raw);
+      if (Number.isFinite(parsed) && parsed > 0)
+        return parsed;
+    }
+    return fallback;
+  };
+  const bool = (v, envKey, fallback) => {
+    if (typeof v === "boolean")
+      return v;
+    const raw = str(v) ?? str(process.env[envKey]);
+    if (raw !== void 0)
+      return raw === "1" || raw.toLowerCase() === "true";
+    return fallback;
+  };
+  return {
+    binaryPath: str(settings?.binaryPath) ?? str(process.env.HERMES_BIN) ?? "hermes",
+    model: str(settings?.model) ?? str(process.env.HERMES_MODEL_ID),
+    provider: str(settings?.provider) ?? str(process.env.HERMES_PROVIDER),
+    maxTurns: num(settings?.maxTurns, "HERMES_MAX_TURNS", 12),
+    yolo: bool(settings?.yolo, "HERMES_YOLO", false),
+    cliTimeoutMs: num(settings?.cliTimeoutMs, "HERMES_CLI_TIMEOUT_MS", 3e5),
+    profile: str(settings?.profile) ?? str(process.env.HERMES_PROFILE)
+  };
+}
+function cleanText(raw) {
+  return raw.replace(ANSI_RE, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function stripChrome(text) {
+  const lines = text.split("\n");
+  const filtered = lines.filter((line) => !CHROME_LINE_RES.some((re) => re.test(line)));
+  return filtered.join("\n").trim();
+}
+function parseHermesOutput(rawStdout, rawStderr) {
+  const cleaned = cleanText(rawStdout);
+  const match = SESSION_ID_RE.exec(cleaned);
+  if (!match) {
+    const combined = [rawStdout, rawStderr].filter(Boolean).join("\n");
+    throw new Error(`hermes: missing session_id in output.
+${combined}`);
+  }
+  const sessionId = match[1];
+  const sessionIdLineStart = cleaned.lastIndexOf("\nsession_id:");
+  const bodyRaw = sessionIdLineStart >= 0 ? cleaned.slice(0, sessionIdLineStart) : cleaned;
+  const body = stripChrome(bodyRaw);
+  return { body, sessionId };
+}
+function buildHermesArgs(prompt, settings, resumeSessionId) {
+  const args = ["chat", "-q", prompt, "-Q", "--source", "tool"];
+  if (resumeSessionId) {
+    args.push("--resume", resumeSessionId);
+  }
+  if (settings.model) {
+    args.push("-m", settings.model);
+  }
+  if (settings.provider) {
+    args.push("--provider", settings.provider);
+  }
+  args.push("--max-turns", String(settings.maxTurns));
+  if (settings.yolo) {
+    args.push("--yolo");
+  }
+  return args;
+}
+async function invokeHermesCli(prompt, settings, resumeSessionId, signal) {
+  const args = buildHermesArgs(prompt, settings, resumeSessionId);
+  const binary = resolveBinaryForSpawn(settings.binaryPath);
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const spawnEnv = { ...process.env, PYTHONUNBUFFERED: "1" };
+    if (settings.profile) {
+      spawnEnv.HERMES_HOME = hermesProfileHome(settings.profile);
+    }
+    const child = spawn(binary, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: spawnEnv
+    });
+    const hardKillTimer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      reject(new Error(`hermes: process timed out after ${settings.cliTimeoutMs}ms`));
+    }, settings.cliTimeoutMs);
+    const onAbort = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(hardKillTimer);
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      reject(new Error("hermes: invocation aborted"));
+    };
+    if (signal) {
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("error", (err) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(hardKillTimer);
+      signal?.removeEventListener("abort", onAbort);
+      const isNotFound = err.code === "ENOENT";
+      reject(new Error(isNotFound ? `hermes: binary not found at "${settings.binaryPath}". Install hermes or set binaryPath/HERMES_BIN.` : `hermes: spawn error \u2014 ${err.message}`));
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(hardKillTimer);
+      signal?.removeEventListener("abort", onAbort);
+      if (code !== 0) {
+        const combined = [stdout, stderr].filter(Boolean).join("\n");
+        reject(new Error(`hermes: process exited with code ${String(code)}.
+${combined}`));
+        return;
+      }
+      try {
+        resolve2(parseHermesOutput(stdout, stderr));
+      } catch (parseErr) {
+        reject(parseErr);
+      }
+    });
+  });
+}
+
+// ../../plugins/fusion-plugin-hermes-runtime/dist/fusion-skill-install.js
+import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, rmSync, symlinkSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var FUSION_SKILL_NAME = "fusion";
+function resolveHermesHome(profile) {
+  const base = process.env.HERMES_HOME ?? join(homedir(), ".hermes");
+  if (!profile || profile === "default")
+    return base;
+  return join(base, "profiles", profile);
+}
+function getFusionSkillSourceCandidates(moduleUrl = import.meta.url) {
+  const here = fileURLToPath(moduleUrl);
+  const moduleDir = dirname(here);
+  return [
+    resolve(moduleDir, "..", "..", "..", "..", "packages", "cli", "skill", FUSION_SKILL_NAME),
+    resolve(moduleDir, "..", "..", "..", "skill", FUSION_SKILL_NAME),
+    resolve(moduleDir, "..", "..", "skill", FUSION_SKILL_NAME),
+    resolve(moduleDir, "..", "..", "..", "..", "skill", FUSION_SKILL_NAME)
+  ];
+}
+function resolveBundledFusionSkillSource() {
+  const candidates = getFusionSkillSourceCandidates();
+  for (const candidate of candidates) {
+    if (existsSync(join(candidate, "SKILL.md")))
+      return candidate;
+  }
+  return null;
+}
+function installFusionSkillIntoHermesHome(options = {}) {
+  const sourceDir = options.sourceDir ?? resolveBundledFusionSkillSource();
+  const targetDir = join(resolveHermesHome(options.profile), "skills", FUSION_SKILL_NAME);
+  if (!sourceDir) {
+    return {
+      outcome: "warning",
+      sourceDir,
+      targetDir,
+      reason: "bundled Fusion skill source directory not found"
+    };
+  }
+  try {
+    mkdirSync(dirname(targetDir), { recursive: true });
+    let replaced = false;
+    if (existsSync(targetDir) || isBrokenSymlink(targetDir)) {
+      const stat = lstatSync(targetDir);
+      if (stat.isSymbolicLink()) {
+        const currentTarget = safeReadlink(targetDir);
+        if (currentTarget && resolve(dirname(targetDir), currentTarget) === resolve(sourceDir)) {
+          return { outcome: "already-installed", sourceDir, targetDir };
+        }
+        if (!looksLikeFusionSkillTarget(resolve(dirname(targetDir), currentTarget ?? ""))) {
+          return {
+            outcome: "skipped",
+            sourceDir,
+            targetDir,
+            reason: "existing symlink does not look like a Fusion skill install"
+          };
+        }
+        unlinkSync(targetDir);
+        replaced = true;
+      } else {
+        if (!looksLikePriorFusionInstall(targetDir)) {
+          return {
+            outcome: "skipped",
+            sourceDir,
+            targetDir,
+            reason: "existing directory does not look like a Fusion skill install"
+          };
+        }
+        rmSync(targetDir, { recursive: true, force: true });
+        replaced = true;
+      }
+    }
+    try {
+      symlinkSync(sourceDir, targetDir, "dir");
+    } catch (error) {
+      const symlinkReason = error instanceof Error ? error.message : String(error);
+      try {
+        cpSync(sourceDir, targetDir, { recursive: true });
+        return {
+          outcome: replaced ? "replaced" : "installed",
+          sourceDir,
+          targetDir,
+          reason: `symlink failed (${symlinkReason}); copied files instead`
+        };
+      } catch (copyError) {
+        return {
+          outcome: "warning",
+          sourceDir,
+          targetDir,
+          reason: copyError instanceof Error ? copyError.message : String(copyError)
+        };
+      }
+    }
+    return { outcome: replaced ? "replaced" : "installed", sourceDir, targetDir };
+  } catch (error) {
+    return {
+      outcome: "warning",
+      sourceDir,
+      targetDir,
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function safeReadlink(path2) {
+  try {
+    return readlinkSync(path2);
+  } catch {
+    return null;
+  }
+}
+function isBrokenSymlink(path2) {
+  try {
+    const stat = lstatSync(path2);
+    return stat.isSymbolicLink() && !existsSync(path2);
+  } catch {
+    return false;
+  }
+}
+function looksLikePriorFusionInstall(path2) {
+  const skillMd = join(path2, "SKILL.md");
+  if (!existsSync(skillMd))
+    return false;
+  try {
+    const body = readFileSync(skillMd, "utf-8");
+    return /\bfusion\b/i.test(body) && /\bskill\b/i.test(body);
+  } catch {
+    return false;
+  }
+}
+function looksLikeFusionSkillTarget(path2) {
+  if (!path2)
+    return false;
+  if (basename(path2).toLowerCase() === FUSION_SKILL_NAME)
+    return true;
+  return existsSync(join(path2, "SKILL.md"));
+}
+
+// ../../plugins/fusion-plugin-hermes-runtime/dist/runtime-adapter.js
+function buildRuntimeContextSection(options) {
+  const skillNames = Array.isArray(options.skills) ? options.skills.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
+  const skillSelection = options.skillSelection;
+  const selectionSkillNames = Array.isArray(skillSelection?.requestedSkillNames) ? skillSelection.requestedSkillNames.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
+  const mergedSkills = skillNames.length > 0 ? skillNames : selectionSkillNames;
+  const lines = [
+    "Fusion runtime context:",
+    `- Tool mode: ${options.tools ?? "coding"}`
+  ];
+  if (mergedSkills.length > 0) {
+    lines.push(`- Requested skills: ${mergedSkills.join(", ")}`);
+  }
+  lines.push("- If fn_* tools are available in your runtime, use them directly for coordination/memory/task actions.");
+  return lines.join("\n");
+}
+var HermesRuntimeAdapter = class {
+  id = "hermes";
+  name = "Hermes Runtime";
+  settings;
+  constructor(settings) {
+    this.settings = resolveCliSettings(settings);
+  }
+  async createSession(options) {
+    const session = {
+      model: void 0,
+      systemPrompt: options.systemPrompt,
+      messages: [],
+      apiKey: void 0,
+      thinkingLevel: void 0,
+      sessionId: "",
+      lastModelDescription: this.describeFromSettings(),
+      callbacks: {
+        onText: options.onText,
+        onThinking: options.onThinking,
+        onToolStart: options.onToolStart,
+        onToolEnd: options.onToolEnd
+      },
+      runtimeContext: options.runtimeContext,
+      fusedSystemPrompt: [options.systemPrompt.trim(), buildRuntimeContextSection(options).trim()].filter((part) => part.length > 0).join("\n\n"),
+      dispose: () => void 0
+    };
+    return { session, sessionFile: void 0 };
+  }
+  async promptWithFallback(session, prompt, _options) {
+    const resumeId = session.sessionId || void 0;
+    const promptWithContext = resumeId ? prompt : `${session.fusedSystemPrompt}
+
+User request:
+${prompt}`;
+    const result = await invokeHermesCli(promptWithContext, this.settings, resumeId);
+    session.sessionId = result.sessionId;
+    session.lastModelDescription = this.describeFromSettings();
+    if (result.body) {
+      session.callbacks.onText?.(result.body);
+    }
+  }
+  describeModel(session) {
+    return session.lastModelDescription || this.describeFromSettings();
+  }
+  async dispose(_session) {
+  }
+  describeFromSettings() {
+    const provider = this.settings.provider;
+    const model = this.settings.model;
+    if (provider && model)
+      return `hermes/${provider}/${model}`;
+    if (model)
+      return `hermes/${model}`;
+    if (provider)
+      return `hermes/${provider}`;
+    return "hermes";
+  }
+};
+
+// ../../plugins/fusion-plugin-hermes-runtime/dist/probe.js
+import { spawn as spawn2 } from "node:child_process";
+var DEFAULT_PROBE_TIMEOUT_MS = 2e3;
+async function probeHermesBinary(opts) {
+  const startedAt = Date.now();
+  const binary = typeof opts?.binaryPath === "string" && opts.binaryPath.trim().length > 0 ? opts.binaryPath.trim() : "hermes";
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+  const resolvedPath = await tryResolveBinaryPath(binary);
+  return new Promise((resolvePromise) => {
+    const finish = (result) => {
+      resolvePromise({ ...result, probeDurationMs: Date.now() - startedAt });
+    };
+    let settled = false;
+    const child = spawn2(resolvedPath ?? binary, ["--version"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      finish({
+        available: false,
+        binaryPath: resolvedPath,
+        reason: `Probe timed out after ${timeoutMs}ms`
+      });
+    }, timeoutMs);
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("error", (err) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      const isNotFound = err.code === "ENOENT";
+      finish({
+        available: false,
+        binaryPath: resolvedPath,
+        reason: isNotFound ? `\`${binary}\` not found on PATH` : err.message
+      });
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (code === 0) {
+        finish({
+          available: true,
+          version: stdout.trim() || void 0,
+          binaryPath: resolvedPath
+        });
+      } else {
+        finish({
+          available: false,
+          binaryPath: resolvedPath,
+          reason: stderr.trim() || `hermes --version exited with code ${String(code)}`
+        });
+      }
+    });
+  });
+}
+async function tryResolveBinaryPath(binary) {
+  return new Promise((resolvePromise) => {
+    const which = process.platform === "win32" ? "where" : "which";
+    const child = spawn2(which, [binary], { stdio: ["ignore", "pipe", "ignore"] });
+    let out = "";
+    child.stdout?.on("data", (chunk) => {
+      out += chunk.toString("utf-8");
+    });
+    child.on("error", () => resolvePromise(void 0));
+    child.on("close", (code) => {
+      if (code === 0) {
+        const first = out.trim().split(/\r?\n/)[0];
+        resolvePromise(first?.length ? first : void 0);
+      } else {
+        resolvePromise(void 0);
+      }
+    });
+  });
+}
+
+// ../../plugins/fusion-plugin-hermes-runtime/dist/index.js
+var HERMES_RUNTIME_ID = "hermes";
+var HERMES_RUNTIME_VERSION = "0.2.0";
+var hermesRuntimeMetadata = {
+  runtimeId: HERMES_RUNTIME_ID,
+  name: "Hermes Runtime",
+  description: "Drives the local `hermes` CLI (NousResearch/hermes-agent)",
+  version: HERMES_RUNTIME_VERSION
+};
+var hermesRuntimeFactory = async (ctx) => {
+  return new HermesRuntimeAdapter(ctx.settings);
+};
+var plugin = definePlugin({
+  manifest: {
+    id: "fusion-plugin-hermes-runtime",
+    name: "Hermes Runtime Plugin",
+    version: HERMES_RUNTIME_VERSION,
+    description: "Drives the local `hermes` CLI for Fusion agents \u2014 captures session ids and resumes via --resume.",
+    author: "Fusion Team",
+    homepage: "https://github.com/NousResearch/hermes-agent",
+    runtime: hermesRuntimeMetadata
+  },
+  state: "installed",
+  hooks: {
+    onLoad: (ctx) => {
+      const settings = resolveCliSettings(ctx.settings);
+      const skillInstall = installFusionSkillIntoHermesHome({ profile: settings.profile });
+      if (skillInstall.outcome === "warning") {
+        ctx.logger.warn(`Hermes Runtime Plugin: Fusion skill auto-install warning: ${skillInstall.reason ?? "unknown"}`);
+      } else if (skillInstall.outcome === "skipped") {
+        ctx.logger.warn(`Hermes Runtime Plugin: Fusion skill auto-install skipped: ${skillInstall.reason ?? "unknown"}`);
+      }
+      ctx.logger.info(`Hermes Runtime Plugin loaded \u2014 binary=${settings.binaryPath} model=${settings.model ?? "(default)"} fusionSkill=${skillInstall.outcome}`);
+      ctx.emitEvent("hermes-runtime:loaded", {
+        runtimeId: HERMES_RUNTIME_ID,
+        version: HERMES_RUNTIME_VERSION
+      });
+    },
+    onUnload: () => {
+    }
+  },
+  runtime: {
+    metadata: hermesRuntimeMetadata,
+    factory: hermesRuntimeFactory
+  }
+});
+var index_default = plugin;
+export {
+  HERMES_RUNTIME_ID,
+  HermesRuntimeAdapter,
+  buildHermesArgs,
+  index_default as default,
+  hermesRuntimeFactory,
+  hermesRuntimeMetadata,
+  installFusionSkillIntoHermesHome,
+  invokeHermesCli,
+  listHermesProfiles,
+  parseHermesOutput,
+  probeHermesBinary,
+  resolveBundledFusionSkillSource,
+  resolveCliSettings,
+  resolveHermesHome
+};

package/dist/plugins/fusion-plugin-hermes-runtime/manifest.json

@@ -0,0 +1,14 @@
+{
+  "id": "fusion-plugin-hermes-runtime",
+  "name": "Hermes Runtime Plugin",
+  "version": "0.1.0",
+  "description": "Hermes AI runtime plugin for Fusion - provides AI agent execution runtime capabilities",
+  "author": "Fusion Team",
+  "homepage": "https://github.com/gsxdsm/fusion",
+  "runtime": {
+    "runtimeId": "hermes",
+    "name": "Hermes Runtime",
+    "description": "Hermes raw-model runtime using pi-ai direct streaming",
+    "version": "0.1.0"
+  }
+}

package/dist/plugins/fusion-plugin-hermes-runtime/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@fusion-plugin-examples/hermes-runtime",
+  "version": "0.2.31",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./bundled.js"
+    }
+  },
+  "private": true
+}