feat: enhance agent functionality with plugin custom folder paths support

Author: NoOne7135

agent/middleware/apiBasedTools.ts

@@ -66,10 +66,15 @@ export function createApiBasedToolsMiddleware(
       const tools = [...enabledApiToolNames]
         .filter((toolName) => !alwaysAvailableApiToolNames.has(toolName))
         .map((toolName) => dynamicTools[toolName]);
+      const availableTools = [...request.tools, ...tools];
+
+      logger.info(
+        `AdminForth Agent callable tools: ${availableTools.map((tool) => tool.name).join(", ")}`,
+      );
 
       return handler({
         ...request,
-        tools: [...request.tools, ...tools],
+        tools: availableTools,
       });
     },
     async wrapToolCall(request, handler) {

agent/simpleAgent.ts

@@ -230,6 +230,7 @@ export async function callAgent(params: {
   adminforth: IAdminForth;
   apiBasedTools: Record<string, ApiBasedTool>;
   customComponentsDir: string;
+  pluginCustomFolderPaths: string[];
   sessionId: string;
   turnId: string;
   currentPage?: CurrentPageContext;
@@ -249,6 +250,7 @@ export async function callAgent(params: {
     adminforth,
     apiBasedTools,
     customComponentsDir,
+    pluginCustomFolderPaths,
     sessionId,
     turnId,
     currentPage,
@@ -258,7 +260,11 @@ export async function callAgent(params: {
     sequenceDebugSink,
   } = params;
 
-  const tools = await createAgentTools(customComponentsDir, apiBasedTools);
+  const tools = await createAgentTools(
+    customComponentsDir,
+    apiBasedTools,
+    pluginCustomFolderPaths,
+  );
   const apiBasedToolsMiddleware = createApiBasedToolsMiddleware(apiBasedTools, adminforth);
   const sequenceDebugMiddleware = createSequenceDebugMiddleware(
     sequenceDebugSink,

agent/skills/registry.ts

@@ -1,16 +1,7 @@
 import { readdir, readFile } from "fs/promises";
 import path from "path";
-import { fileURLToPath } from "url";
 import { parse as parseYaml } from "yaml";
 
-const PLUGIN_SKILLS_DIRECTORY_PATH = fileURLToPath(
-  new URL("../../custom/skills/", import.meta.url),
-);
-const USER_PLUGIN_SKILLS_DIRECTORY_PATH_SEGMENTS = [
-  "plugins",
-  "adminforth-agent",
-  "skills",
-];
 const SKILL_MARKDOWN_FILENAME = "SKILL.md";
 const SKILL_FRONTMATTER_SEPARATOR = "\n---\n";
 
@@ -21,6 +12,13 @@ export interface AgentSkillManifest {
   instructions: string;
 }
 
+function normalizePluginSkillDirectoryPaths(pluginCustomFolderPaths: string[] = []) {
+  return Array.from(new Set(
+    pluginCustomFolderPaths
+      .map((pluginCustomFolderPath) => path.resolve(pluginCustomFolderPath, "skills")),
+  ));
+}
+
 function parseSkillManifest(directoryName: string, markdown: string): AgentSkillManifest {
   const [frontmatterBlock, instructions = ""] = markdown.split("\r\n").join("\n").split(
     SKILL_FRONTMATTER_SEPARATOR,
@@ -83,43 +81,42 @@ export function getProjectSkillsDirectoryPath(customComponentsDir: string) {
   return path.resolve(customComponentsDir, "skills");
 }
 
-export function getProjectPluginSkillsDirectoryPath(customComponentsDir: string) {
-  return path.resolve(
-    customComponentsDir,
-    ...USER_PLUGIN_SKILLS_DIRECTORY_PATH_SEGMENTS,
-  );
-}
-
-function getProjectSkillDirectoryPaths(customComponentsDir: string) {
-  return [
+function getProjectSkillDirectoryPaths(
+  customComponentsDir: string,
+  pluginCustomFolderPaths: string[] = [],
+) {
+  return Array.from(new Set([
     getProjectSkillsDirectoryPath(customComponentsDir),
-    getProjectPluginSkillsDirectoryPath(customComponentsDir),
-  ];
-}
-
-export async function listBundledSkillManifests() {
-  return await listDirectorySkillManifests(PLUGIN_SKILLS_DIRECTORY_PATH);
+    ...normalizePluginSkillDirectoryPaths(pluginCustomFolderPaths),
+  ]));
 }
 
-export async function listProjectSkillManifests(customComponentsDir: string) {
+export async function listProjectSkillManifests(
+  customComponentsDir: string,
+  pluginCustomFolderPaths: string[] = [],
+) {
   return mergeSkillManifests(
     await Promise.all(
-      getProjectSkillDirectoryPaths(customComponentsDir).map(
+      getProjectSkillDirectoryPaths(customComponentsDir, pluginCustomFolderPaths).map(
         listDirectorySkillManifests,
       ),
     ),
   );
 }
 
-export async function listSkillManifests(customComponentsDir: string) {
-  return mergeSkillManifests([
-    await listProjectSkillManifests(customComponentsDir),
-    await listBundledSkillManifests(),
-  ]);
+export async function listSkillManifests(
+  customComponentsDir: string,
+  pluginCustomFolderPaths: string[] = [],
+) {
+  return await listProjectSkillManifests(customComponentsDir, pluginCustomFolderPaths);
 }
 
-export async function loadSkillManifest(skillName: string, customComponentsDir: string) {
-  const manifests = await listSkillManifests(customComponentsDir);
+export async function loadSkillManifest(
+  skillName: string,
+  customComponentsDir: string,
+  pluginCustomFolderPaths: string[] = [],
+) {
+  const manifests = await listSkillManifests(customComponentsDir, pluginCustomFolderPaths);
 
   return (
     manifests.find(
@@ -129,16 +126,23 @@ export async function loadSkillManifest(skillName: string, customComponentsDir:
   );
 }
 
-export async function loadSkillMarkdown(skillName: string, customComponentsDir: string) {
-  const manifest = await loadSkillManifest(skillName, customComponentsDir);
+export async function loadSkillMarkdown(
+  skillName: string,
+  customComponentsDir: string,
+  pluginCustomFolderPaths: string[] = [],
+) {
+  const manifest = await loadSkillManifest(
+    skillName,
+    customComponentsDir,
+    pluginCustomFolderPaths,
+  );
 
   if (!manifest) {
     return null;
   }
 
   const directories = [
-    ...getProjectSkillDirectoryPaths(customComponentsDir),
-    PLUGIN_SKILLS_DIRECTORY_PATH,
+    ...getProjectSkillDirectoryPaths(customComponentsDir, pluginCustomFolderPaths),
   ];
 
   for (const skillsDirectoryPath of directories) {

agent/systemPrompt.ts

@@ -1,7 +1,6 @@
 import type { AdminForthResource, AdminUser, IAdminForth } from "adminforth";
 import type { DetectedLanguage } from "./languageDetect.js";
 import {
-  listBundledSkillManifests,
   listProjectSkillManifests,
   type AgentSkillManifest,
 } from "./skills/registry.js";
@@ -96,10 +95,12 @@ export async function buildAgentSystemPrompt(
   hiddenResourceIds: Iterable<string> = [],
 ) {
   const customComponentsDir = adminforth.config.customization.customComponentsDir ?? "custom";
-  const [primarySkills, defaultSkills] = await Promise.all([
-    listProjectSkillManifests(customComponentsDir),
-    listBundledSkillManifests(),
-  ]);
+  const pluginCustomFolderPaths = adminforth.activatedPlugins
+    .map((plugin) => plugin.customFolderPath);
+  const skills = await listProjectSkillManifests(
+    customComponentsDir,
+    pluginCustomFolderPaths,
+  );
   const adminBasePath = adminforth.config.baseUrlSlashed;
   const hiddenResourceIdSet = new Set(hiddenResourceIds);
   const visibleResources = adminforth.config.resources.filter(
@@ -109,11 +110,9 @@ export async function buildAgentSystemPrompt(
     DEFAULT_AGENT_SYSTEM_PROMPT,
     `ADMIN_BASE_PATH: ${adminBasePath}`,
     `List of resources:\n${formatResources(visibleResources)}`,
-    primarySkills.length > 0
-      ? `You have primary skills set:\n${formatSkills(primarySkills, "skill_name")}`
+    skills.length > 0
+      ? `You have skills set:\n${formatSkills(skills, "skill_name")}`
       : "",
-    "You have next default skills which you can fallback to if primary skill set does not provide a good skill:\n" +
-      formatSkills(defaultSkills, "skill_name"),
     "Before using any skill, call fetch_skill to load its full instructions.",
     "The fetched skill response starts with 'Tools mentioned in this skill'. Read that list first.",
     "You can use get_resource immediately to inspect resource structure and column names.",
@@ -123,8 +122,8 @@ export async function buildAgentSystemPrompt(
     "If a fetched skill lists a non-base tool you need, call fetch_tool_schema for it immediately instead of telling the user the tool is unavailable.",
     "For example: for record creation load mutate_data, read its tool list, call fetch_tool_schema for create_record, and then use create_record after confirmation.",
     "When fetch_tool_schema succeeds, that tool becomes available on the next step.",
-    "All admin links must be relative paths and must start with ADMIN_BASE_PATH.",
-    "Build record links as ADMIN_BASE_PATH + resource/{resourceId}/show/{primary key}. Do not prepend any extra slash before resource.",
+    "All admin links must be root-relative and start with '/'.",
+    "Build record links as '/resource/{resourceId}/show/{primary key}'. Never use bare 'resource/{resourceId}/show/{primary key}' without the leading slash.",
     "Try to call as many tools as possible in parallel in one step.",
   ];
 

agent/tools/fetchSkill.ts

@@ -21,14 +21,24 @@ function serializeSkillManifests(skillManifests: AgentSkillManifest[]) {
   }));
 }
 
-export async function createFetchSkillTool(customComponentsDir: string) {
-  const availableSkills = await listSkillManifests(customComponentsDir);
+export async function createFetchSkillTool(
+  customComponentsDir: string,
+  pluginCustomFolderPaths: string[] = [],
+) {
+  const availableSkills = await listSkillManifests(
+    customComponentsDir,
+    pluginCustomFolderPaths,
+  );
   const availableSkillNames = availableSkills.map((skill) => skill.name);
 
   return tool(
     async ({ skillName }) => {
       try {
-        const skillMarkdown = await loadSkillMarkdown(skillName, customComponentsDir);
+        const skillMarkdown = await loadSkillMarkdown(
+          skillName,
+          customComponentsDir,
+          pluginCustomFolderPaths,
+        );
 
         if (!skillMarkdown) {
           return [

agent/tools/index.ts

@@ -10,6 +10,7 @@ export const ALWAYS_AVAILABLE_API_TOOL_NAMES = ["get_resource"] as const;
 export async function createAgentTools(
   customComponentsDir: string,
   apiBasedTools: Record<string, ApiBasedTool>,
+  pluginCustomFolderPaths: string[] = [],
 ): Promise<ClientTool[]> {
   return [
     ...ALWAYS_AVAILABLE_API_TOOL_NAMES.map((toolName) => {
@@ -22,7 +23,7 @@ export async function createAgentTools(
       return createApiTool(toolName, apiBasedTool);
     }),
     createGetUserLocationTool(),
-    await createFetchSkillTool(customComponentsDir),
+    await createFetchSkillTool(customComponentsDir, pluginCustomFolderPaths),
     await createFetchToolSchemaTool(apiBasedTools),
   ];
 }

agentTurnService.ts

@@ -138,6 +138,7 @@ export class AgentTurnService {
       adminforth,
       apiBasedTools,
       customComponentsDir: adminforth.config.customization.customComponentsDir ?? "custom",
+      pluginCustomFolderPaths: adminforth.activatedPlugins.map((plugin) => plugin.customFolderPath),
       sessionId: input.sessionId,
       turnId: input.turnId,
       currentPage: input.currentPage,

custom/composables/agentStore/useAgentSessions.ts

@@ -3,7 +3,7 @@ import { callAdminForthApi } from '@/utils';
 import type { Chat } from '../../chat';
 import type { IAgentSession, ISessionsListItem, IPart } from '../../types';
 import { PRE_SESSION_ID } from './constants';
-import { useI18n } from 'vue-i18n';
+import { i18nInstance } from '@/i18n';
 
 type AdminforthLike = {
   confirm(options: { message: string; yes: string; no: string }): Promise<boolean>;
@@ -42,7 +42,10 @@ export function createAgentSessionManager({
     return [...sessionsListToSort].sort((a: ISessionsListItem, b: ISessionsListItem) => b.timestamp.localeCompare(a.timestamp));
   }
 
-  const { t } = useI18n();
+  function t(key: string) {
+    return i18nInstance?.global.t(key) ?? key;
+  }
+
   function saveCurrentSessionInCache() {
     if (currentSession.value) {
       currentSession.value.messages = currentChat.value?.messages.map((m: any) => ({
@@ -342,4 +345,4 @@ export function createAgentSessionManager({
     setCurrentChatStatus,
     updateLastAgentMessage
   };
-}
+}

custom/conversation_area/TextRenderer.vue

@@ -115,7 +115,11 @@
       return `${window.location.pathname}${window.location.search}${href}`;
     }
 
-    const resolvedUrl = new URL(href, window.location.href);
+    const isAbsoluteWithScheme = /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(href);
+    const baseUrl = isAbsoluteWithScheme
+      ? undefined
+      : `${window.location.origin}/`;
+    const resolvedUrl = new URL(href, baseUrl ?? window.location.href);
     if (resolvedUrl.origin !== window.location.origin) {
       return null;
     }