@lupaflow/plugins 0.1.0

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name":  "@lupaflow/plugins",
+    "version":  "0.1.0",
+    "type":  "module",
+    "license":  "MIT",
+    "publishConfig":  {
+                          "access":  "public"
+                      },
+    "main":  "./dist/index.js",
+    "module":  "./dist/index.js",
+    "types":  "./dist/index.d.ts",
+    "exports":  {
+                    ".":  {
+                              "types":  "./dist/index.d.ts",
+                              "require":  "./dist/index.js",
+                              "import":  "./dist/index.js"
+                          }
+                },
+    "scripts":  {
+                    "build":  "tsup",
+                    "dev":  "tsup --watch"
+                },
+    "dependencies":  {
+                         "@lupaflow/core":  "workspace:*",
+                         "@lupaflow/types":  "workspace:*"
+                     },
+    "devDependencies":  {
+                            "tsup":  "^8.3.0",
+                            "typescript":  "^5.6.0"
+                        }
+}

package/src/hooks.ts

@@ -0,0 +1,61 @@
+import { pluginManager } from "./loader"
+
+export function runBeforeAgentRunHooks(config: Record<string, unknown>): Record<string, unknown> {
+  let result = { ...config }
+  for (const plugin of pluginManager.list()) {
+    if (plugin.hooks?.beforeAgentRun) {
+      result = plugin.hooks.beforeAgentRun(result)
+    }
+  }
+  return result
+}
+
+export function runAfterAgentRunHooks(result: unknown): unknown {
+  let output = result
+  for (const plugin of pluginManager.list()) {
+    if (plugin.hooks?.afterAgentRun) {
+      output = plugin.hooks.afterAgentRun(output)
+    }
+  }
+  return output
+}
+
+export function runBeforeToolCallHooks(tool: string, args: Record<string, unknown>): Record<string, unknown> {
+  let result = { ...args }
+  for (const plugin of pluginManager.list()) {
+    if (plugin.hooks?.beforeToolCall) {
+      result = plugin.hooks.beforeToolCall(tool, result)
+    }
+  }
+  return result
+}
+
+export function runAfterToolCallHooks(result: unknown): unknown {
+  let output = result
+  for (const plugin of pluginManager.list()) {
+    if (plugin.hooks?.afterToolCall) {
+      output = plugin.hooks.afterToolCall(output)
+    }
+  }
+  return output
+}
+
+export function runBeforeProviderCallHooks(provider: string, request: Record<string, unknown>): Record<string, unknown> {
+  let result = { ...request }
+  for (const plugin of pluginManager.list()) {
+    if (plugin.hooks?.beforeProviderCall) {
+      result = plugin.hooks.beforeProviderCall(provider, result)
+    }
+  }
+  return result
+}
+
+export function runAfterProviderCallHooks(response: Record<string, unknown>): Record<string, unknown> {
+  let result = { ...response }
+  for (const plugin of pluginManager.list()) {
+    if (plugin.hooks?.afterProviderCall) {
+      result = plugin.hooks.afterProviderCall(result)
+    }
+  }
+  return result
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export { pluginManager } from "./loader"
+export type { LupaPlugin } from "./interface"
+export {
+  runBeforeAgentRunHooks,
+  runAfterAgentRunHooks,
+  runBeforeToolCallHooks,
+  runAfterToolCallHooks,
+  runBeforeProviderCallHooks,
+  runAfterProviderCallHooks,
+} from "./hooks"

package/src/interface.ts

@@ -0,0 +1,18 @@
+import type { LupaEvent } from "@lupaflow/types"
+
+export interface LupaPlugin {
+  name: string
+  version: string
+  description?: string
+  onLoad?: () => void | Promise<void>
+  onUnload?: () => void | Promise<void>
+  onEvent?: (event: LupaEvent) => void | Promise<void>
+  hooks?: {
+    beforeAgentRun?: (config: Record<string, unknown>) => Record<string, unknown>
+    afterAgentRun?: (result: unknown) => unknown
+    beforeToolCall?: (tool: string, args: Record<string, unknown>) => Record<string, unknown>
+    afterToolCall?: (result: unknown) => unknown
+    beforeProviderCall?: (provider: string, request: Record<string, unknown>) => Record<string, unknown>
+    afterProviderCall?: (response: Record<string, unknown>) => Record<string, unknown>
+  }
+}

package/src/loader.ts

@@ -0,0 +1,67 @@
+import { readdir } from "fs/promises"
+import { join } from "path"
+import type { LupaPlugin } from "./interface"
+import { globalEventBus } from "@lupaflow/core"
+
+class PluginManager {
+  private plugins: Map<string, LupaPlugin> = new Map()
+  private loaded = false
+
+  async load(plugin: LupaPlugin): Promise<void> {
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin "${plugin.name}" is already loaded`)
+    }
+    this.plugins.set(plugin.name, plugin)
+
+    if (plugin.onEvent) {
+      globalEventBus.onAny((event) => plugin.onEvent!(event))
+    }
+
+    if (plugin.onLoad) {
+      await plugin.onLoad()
+    }
+  }
+
+  async unload(name: string): Promise<void> {
+    const plugin = this.plugins.get(name)
+    if (!plugin) throw new Error(`Plugin "${name}" not found`)
+    if (plugin.onUnload) await plugin.onUnload()
+    this.plugins.delete(name)
+  }
+
+  async loadFromDirectory(dir: string): Promise<void> {
+    try {
+      const files = await readdir(dir)
+      for (const file of files) {
+        if (file.endsWith(".js") || file.endsWith(".mjs")) {
+          try {
+            const mod = await import(join(dir, file))
+            if (mod.default && mod.default.name) {
+              await this.load(mod.default)
+            }
+          } catch { /* ignore */ }
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
+  get(name: string): LupaPlugin | undefined {
+    return this.plugins.get(name)
+  }
+
+  list(): LupaPlugin[] {
+    return Array.from(this.plugins.values())
+  }
+
+  isLoaded(name: string): boolean {
+    return this.plugins.has(name)
+  }
+
+  async unloadAll(): Promise<void> {
+    for (const [name] of this.plugins) {
+      await this.unload(name)
+    }
+  }
+}
+
+export const pluginManager = new PluginManager()

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup"
+export default defineConfig({
+  entry: { index: "src/index.ts" },
+  format: ["cjs", "esm"],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  external: [/node_modules/],
+})