@adminforth/agent 1.49.2 → 1.50.0

package/agent/middleware/sequenceDebug.ts

@@ -26,6 +26,9 @@ export type SequenceDebug = {
   reasoningTokens: number;
   text: string;
   textTokens: number;
+  uncachedInputTokens: number;
+  cachedInputTokens: number;
+  outputTokens: number;
   cachedTokens: number;
   responseId: string | null;
   toolCalls: SequenceDebugToolCall[];
@@ -45,6 +48,9 @@ type SequenceDebugModelCall = {
   reasoningTokens: number;
   text: string;
   textTokens: number;
+  uncachedInputTokens: number;
+  cachedInputTokens: number;
+  outputTokens: number;
   cachedTokens: number;
   responseId: string | null;
   resultType: SequenceDebugResultType;
@@ -52,6 +58,7 @@ type SequenceDebugModelCall = {
 
 type OpenAiUsageMetadata = {
   input_tokens?: number;
+  output_tokens?: number;
   input_token_details?: {
     cache_read?: number;
   };
@@ -82,6 +89,9 @@ function createPendingSequenceDebug(sequenceId: number): PendingSequenceDebug {
     reasoningTokens: 0,
     text: "",
     textTokens: 0,
+    uncachedInputTokens: 0,
+    cachedInputTokens: 0,
+    outputTokens: 0,
     cachedTokens: 0,
     responseId: null,
     toolCalls: [],
@@ -112,6 +122,9 @@ function finalizeSequenceDebug(sequence: PendingSequenceDebug): SequenceDebug {
     reasoningTokens: sequence.reasoningTokens,
     text: sequence.text,
     textTokens: sequence.textTokens,
+    uncachedInputTokens: sequence.uncachedInputTokens,
+    cachedInputTokens: sequence.cachedInputTokens,
+    outputTokens: sequence.outputTokens,
     cachedTokens: sequence.cachedTokens,
     responseId: sequence.responseId,
     toolCalls: sequence.toolCalls.map(({ completed: _completed, ...toolCall }) => toolCall),
@@ -133,6 +146,21 @@ function getDebugModelName(model: SequenceDebugPromptModel) {
   return typeof model.getName === "function" ? model.getName() : undefined;
 }
 
+function getDebugToolName(tool: unknown) {
+  if (!tool || typeof tool !== "object") {
+    return null;
+  }
+
+  const name = (tool as { name?: unknown }).name;
+  return typeof name === "string" ? name : null;
+}
+
+function formatToolsForDebug(tools: unknown[]) {
+  return tools.map((tool) => ({
+    name: getDebugToolName(tool),
+  }));
+}
+
 function stringifyPromptForDebug(params: {
   model: SequenceDebugPromptModel;
   systemMessage: { text: string };
@@ -160,7 +188,7 @@ function stringifyPromptForDebug(params: {
     },
     systemMessage,
     messages,
-    ...(tools.length > 0 ? { tools } : {}),
+    ...(tools.length > 0 ? { tools: formatToolsForDebug(tools) } : {}),
     ...(toolChoice !== undefined ? { toolChoice } : {}),
     ...(modelSettings ? { modelSettings } : {}),
     ...(invocationParams ? { invocationParams } : {}),
@@ -219,6 +247,9 @@ async function countTokens(model: unknown, content: string) {
 }
 
 function extractSequenceResponseDebug(message: AIMessage): SequenceDebugModelCall {
+  const usageMetadata = message.usage_metadata as OpenAiUsageMetadata | undefined;
+  const promptTokens = usageMetadata?.input_tokens ?? 0;
+  const cachedInputTokens = usageMetadata?.input_token_details?.cache_read ?? 0;
   const blocks = getMessageBlocks(message);
   const reasoning = blocks
     .filter((block: any) => block?.type === "reasoning")
@@ -230,16 +261,15 @@ function extractSequenceResponseDebug(message: AIMessage): SequenceDebugModelCal
     .join("");
 
   return {
-    promptTokens:
-      (message.usage_metadata as OpenAiUsageMetadata | undefined)?.input_tokens ??
-      0,
+    promptTokens,
     reasoning,
     reasoningTokens: 0,
     text: textFromBlocks || (typeof message.content === "string" ? message.content : ""),
     textTokens: 0,
-    cachedTokens:
-      (message.usage_metadata as OpenAiUsageMetadata | undefined)
-        ?.input_token_details?.cache_read ?? 0,
+    uncachedInputTokens: Math.max(promptTokens - cachedInputTokens, 0),
+    cachedInputTokens,
+    outputTokens: usageMetadata?.output_tokens ?? 0,
+    cachedTokens: cachedInputTokens,
     responseId:
       (message.response_metadata as OpenAiResponseMetadata | undefined)?.id ??
       null,
@@ -290,6 +320,9 @@ export function createSequenceDebugCollector(): SequenceDebugCollector {
       sequenceDebug.reasoningTokens = params.reasoningTokens;
       sequenceDebug.text = params.text;
       sequenceDebug.textTokens = params.textTokens;
+      sequenceDebug.uncachedInputTokens = params.uncachedInputTokens;
+      sequenceDebug.cachedInputTokens = params.cachedInputTokens;
+      sequenceDebug.outputTokens = params.outputTokens;
       sequenceDebug.cachedTokens = params.cachedTokens;
       sequenceDebug.responseId = params.responseId;
       sequenceDebug.resultType = params.resultType;
@@ -387,6 +420,8 @@ export function createSequenceDebugMiddleware(
         promptTokens,
         reasoningTokens,
         textTokens,
+        uncachedInputTokens: debug.promptTokens ? debug.uncachedInputTokens : promptTokens,
+        outputTokens: debug.outputTokens || reasoningTokens + textTokens,
       });
       return response;
     },

package/agent/simpleAgent.ts

@@ -19,6 +19,7 @@ import {
 import type { ApiBasedTool } from "../apiBasedTools.js";
 import type { ToolCallEventSink } from "./toolCallEvents.js";
 import type { CurrentPageContext } from "./tools/getUserLocation.js";
+import type { AgentEventEmitter } from "../agentEvents.js";
 
 export const contextSchema = z.object({
   adminUser: z.custom<AdminUser>(),
@@ -27,7 +28,11 @@ export const contextSchema = z.object({
   turnId: z.string(),
   abortSignal: z.custom<AbortSignal>().optional(),
   currentPage: z.custom<CurrentPageContext>().optional(),
+  chatSurface: z.string().optional(),
+  adminBaseUrl: z.string().optional(),
+  adminPublicOrigin: z.string().optional(),
   emitToolCallEvent: z.custom<ToolCallEventSink>(),
+  emitAgentEvent: z.custom<AgentEventEmitter>().optional(),
 });
 
 export type AgentChatModel = BaseChatModel<any, any>;
@@ -234,9 +239,12 @@ export async function callAgent(params: {
   sessionId: string;
   turnId: string;
   currentPage?: CurrentPageContext;
+  chatSurface?: string;
+  adminPublicOrigin?: string;
   userTimeZone: string;
   abortSignal?: AbortSignal;
   emitToolCallEvent: ToolCallEventSink;
+  emitAgentEvent?: AgentEventEmitter;
   sequenceDebugSink: SequenceDebugModelCallSink;
 }) {
   const {
@@ -254,9 +262,12 @@ export async function callAgent(params: {
     sessionId,
     turnId,
     currentPage,
+    chatSurface,
+    adminPublicOrigin,
     userTimeZone,
     abortSignal,
     emitToolCallEvent,
+    emitAgentEvent,
     sequenceDebugSink,
   } = params;
 
@@ -305,7 +316,11 @@ export async function callAgent(params: {
       turnId,
       abortSignal,
       currentPage,
+      chatSurface,
+      adminBaseUrl: adminforth.config.baseUrlSlashed,
+      adminPublicOrigin,
       emitToolCallEvent,
+      emitAgentEvent,
     },
   });
 }

package/agent/systemPrompt.ts

@@ -70,12 +70,16 @@ export function buildAgentTurnSystemPrompt(input: {
   adminUser: AdminUser;
   usernameField: string;
   userLanguage: DetectedLanguage | null;
+  chatSurface?: string;
 }) {
   return [
     input.agentSystemPrompt,
     formatAdminUserPrompt(input.adminUser, input.usernameField),
+    input.chatSurface
+      ? `Current chat surface: ${input.chatSurface}. The user is not in the AdminForth web UI, so tools cannot move their browser. When navigate_user returns a link, send that link to the user.`
+      : "",
     formatLanguagePrompt(input.userLanguage),
-  ].join("\n\n");
+  ].filter(Boolean).join("\n\n");
 }
 
 function formatResources(resources: AdminForthResource[]) {
@@ -124,6 +128,7 @@ export async function buildAgentSystemPrompt(
     "When fetch_tool_schema succeeds, that tool becomes available on the next step.",
     "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.",
+    "When the user asks to open or show a page in the AdminForth UI, call navigate_user instead of only sending a link.",
     "Try to call as many tools as possible in parallel in one step.",
   ];
 

package/agent/tools/index.ts

@@ -4,6 +4,7 @@ import { createFetchToolSchemaTool } from "./fetchToolSchema.js";
 import type { ApiBasedTool } from "../../apiBasedTools.js";
 import { createApiTool } from "./apiTool.js";
 import { createGetUserLocationTool } from "./getUserLocation.js";
+import { createNavigateUserTool } from "./navigateUser.js";
 
 export const ALWAYS_AVAILABLE_API_TOOL_NAMES = ["get_resource"] as const;
 
@@ -23,6 +24,7 @@ export async function createAgentTools(
       return createApiTool(toolName, apiBasedTool);
     }),
     createGetUserLocationTool(),
+    createNavigateUserTool(),
     await createFetchSkillTool(customComponentsDir, pluginCustomFolderPaths),
     await createFetchToolSchemaTool(apiBasedTools),
   ];

package/agent/tools/navigateUser.ts

@@ -0,0 +1,210 @@
+import { tool } from "langchain";
+import { z } from "zod";
+import type { CurrentPageContext } from "./getUserLocation.js";
+import type { AgentEventEmitter } from "../../agentEvents.js";
+
+const filterSchema = z.object({
+  column: z.string().min(1).describe("Resource column name."),
+  operator: z
+    .string()
+    .min(1)
+    .describe("Filter operator suffix, for example eq, gte, lte, like, in."),
+  value: z.unknown().describe("Filter value. Dates should be ISO strings."),
+});
+
+const navigateUserSchema = z
+  .object({
+    targetPath: z
+      .string()
+      .optional()
+      .describe(
+        "Root-relative AdminForth path to open, with optional query string and hash, for example /resource/adminuser?sort=created_at__desc.",
+      ),
+    resourceId: z
+      .string()
+      .optional()
+      .describe("Resource id to build an AdminForth resource route for."),
+    mode: z
+      .enum(["list", "show", "edit", "create"])
+      .optional()
+      .default("list")
+      .describe("Resource page mode. Defaults to list."),
+    recordId: z
+      .union([z.string(), z.number()])
+      .optional()
+      .describe("Record primary key for show or edit resource pages."),
+    filters: z
+      .array(filterSchema)
+      .optional()
+      .describe(
+        "List page filters. Each item becomes filter__{column}__{operator}=JSON.stringify(value).",
+      ),
+    sort: z
+      .object({
+        column: z.string().min(1),
+        direction: z.enum(["asc", "desc"]),
+      })
+      .optional()
+      .describe("List page sort. Becomes sort={column}__{direction}."),
+    query: z
+      .record(z.string(), z.union([z.string(), z.number(), z.boolean()]))
+      .optional()
+      .describe("Additional query parameters to append to the target URL."),
+  })
+  .refine((input) => input.targetPath || input.resourceId, {
+    message: "Either targetPath or resourceId is required.",
+  });
+
+function normalizeTargetPath(targetPath: string, currentPage?: CurrentPageContext) {
+  const trimmed = targetPath.trim();
+
+  if (!trimmed) {
+    throw new Error("targetPath cannot be empty.");
+  }
+
+  const currentOrigin = currentPage?.url ? new URL(currentPage.url).origin : undefined;
+
+  if (currentOrigin) {
+    const targetUrl = new URL(trimmed, currentOrigin);
+
+    if (targetUrl.origin !== currentOrigin) {
+      throw new Error("Only same-origin navigation targets are allowed.");
+    }
+
+    return `${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`;
+  }
+
+  const fallbackOrigin = "http://adminforth.local";
+  const targetUrl = new URL(trimmed, fallbackOrigin);
+
+  if (targetUrl.origin !== fallbackOrigin) {
+    throw new Error("Only relative AdminForth paths are allowed when current origin is unavailable.");
+  }
+
+  return `${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`;
+}
+
+function appendQueryParams(path: string, params: URLSearchParams) {
+  const queryString = params.toString();
+
+  if (!queryString) {
+    return path;
+  }
+
+  const hashIndex = path.indexOf("#");
+  const pathWithoutHash = hashIndex === -1 ? path : path.slice(0, hashIndex);
+  const hash = hashIndex === -1 ? "" : path.slice(hashIndex);
+  const separator = pathWithoutHash.includes("?") ? "&" : "?";
+
+  return `${pathWithoutHash}${separator}${queryString}${hash}`;
+}
+
+function buildResourcePath(input: z.infer<typeof navigateUserSchema>) {
+  if (!input.resourceId) {
+    throw new Error("resourceId is required to build a resource route.");
+  }
+
+  const resourceId = encodeURIComponent(input.resourceId);
+  const mode = input.mode ?? "list";
+
+  if (mode === "show" || mode === "edit") {
+    if (input.recordId === undefined || input.recordId === null) {
+      throw new Error(`recordId is required for ${mode} resource pages.`);
+    }
+
+    return `/resource/${resourceId}/${mode}/${encodeURIComponent(String(input.recordId))}`;
+  }
+
+  if (mode === "create") {
+    return `/resource/${resourceId}/create`;
+  }
+
+  return `/resource/${resourceId}`;
+}
+
+function buildQueryParams(input: z.infer<typeof navigateUserSchema>) {
+  const params = new URLSearchParams();
+
+  for (const filter of input.filters ?? []) {
+    params.set(
+      `filter__${filter.column}__${filter.operator}`,
+      JSON.stringify(filter.value),
+    );
+  }
+
+  if (input.sort) {
+    params.set("sort", `${input.sort.column}__${input.sort.direction}`);
+  }
+
+  for (const [key, value] of Object.entries(input.query ?? {})) {
+    params.set(key, String(value));
+  }
+
+  return params;
+}
+
+function buildSurfaceUrl(targetPath: string, adminBaseUrl?: string, adminPublicOrigin?: string) {
+  const normalizedBasePath = adminBaseUrl?.replace(/\/+$/, "") ?? "";
+  const normalizedTargetPath = targetPath.replace(/^\/+/, "");
+  const path = `${normalizedBasePath}/${normalizedTargetPath}`;
+
+  return adminPublicOrigin ? new URL(path, adminPublicOrigin).toString() : path;
+}
+
+export function createNavigateUserTool() {
+  return tool(
+    async (input, runtime) => {
+      const context = runtime.context as {
+        currentPage?: CurrentPageContext;
+        chatSurface?: string;
+        adminBaseUrl?: string;
+        adminPublicOrigin?: string;
+        emitAgentEvent?: AgentEventEmitter;
+      };
+      const currentPage = context.currentPage;
+      const basePath = input.targetPath
+        ? normalizeTargetPath(input.targetPath, currentPage)
+        : buildResourcePath(input);
+      const targetPath = appendQueryParams(basePath, buildQueryParams(input));
+
+      if (context.chatSurface) {
+        const url = buildSurfaceUrl(targetPath, context.adminBaseUrl, context.adminPublicOrigin);
+
+        return JSON.stringify(
+          {
+            status: 200,
+            action: "link",
+            surface: context.chatSurface,
+            targetPath,
+            url,
+            message: `Send this link to the user: ${url}`,
+          },
+          null,
+          2,
+        );
+      }
+
+      await context.emitAgentEvent?.({
+        type: "open-page",
+        targetPath,
+      });
+
+      return JSON.stringify(
+        {
+          status: 200,
+          action: "navigate",
+          targetPath,
+          message: `Navigation requested to ${targetPath}.`,
+        },
+        null,
+        2,
+      );
+    },
+    {
+      name: "navigate_user",
+      description:
+        "Navigate the user to another AdminForth page. Use this only when the user asks to open, show, go to, or switch to a resource list/detail page, including filtered or sorted resource lists. Or if the user is asked to open something on the left. Do not use this tool in any other case.",
+      schema: navigateUserSchema,
+    },
+  );
+}

package/agentEvents.ts

@@ -22,6 +22,10 @@ export type AgentEvent =
       phase: "start" | "end";
       label: string;
     }
+  | {
+      type: "open-page";
+      targetPath: string;
+    }
   | {
       type: "transcript";
       text: string;

package/agentTurnService.ts

@@ -23,6 +23,8 @@ type AgentTurnRunInput = {
   modeName?: string | null;
   userTimeZone: string;
   currentPage?: CurrentPageContext;
+  chatSurface?: string;
+  adminPublicOrigin?: string;
   abortSignal?: AbortSignal;
   adminUser: AdminUser;
   sequenceDebugCollector: ReturnType<typeof createSequenceDebugCollector>;
@@ -35,6 +37,8 @@ export type RunAndPersistAgentResponseInput = {
   modeName?: string | null;
   userTimeZone: string;
   currentPage?: CurrentPageContext;
+  chatSurface?: string;
+  adminPublicOrigin?: string;
   abortSignal?: AbortSignal;
   adminUser: AdminUser;
   emit?: AgentEventEmitter;
@@ -118,6 +122,7 @@ export class AgentTurnService {
       adminUser: input.adminUser,
       usernameField: adminforth.config.auth!.usernameField,
       userLanguage,
+      chatSurface: input.chatSurface,
     });
     const apiBasedTools = buildApiBasedTools(
       adminforth,
@@ -142,6 +147,8 @@ export class AgentTurnService {
       sessionId: input.sessionId,
       turnId: input.turnId,
       currentPage: input.currentPage,
+      chatSurface: input.chatSurface,
+      adminPublicOrigin: input.adminPublicOrigin,
       userTimeZone: input.userTimeZone,
       abortSignal: input.abortSignal,
       emitToolCallEvent: (event) => {
@@ -151,6 +158,7 @@ export class AgentTurnService {
           data: event,
         });
       },
+      emitAgentEvent: input.emit,
       sequenceDebugSink: input.sequenceDebugCollector,
     });
 
@@ -278,6 +286,8 @@ export class AgentTurnService {
         modeName: input.modeName,
         userTimeZone: input.userTimeZone,
         currentPage: input.currentPage,
+        chatSurface: input.chatSurface,
+        adminPublicOrigin: input.adminPublicOrigin,
         abortSignal: input.abortSignal,
         adminUser: input.adminUser,
         sequenceDebugCollector,
@@ -326,6 +336,8 @@ export class AgentTurnService {
       modeName: input.modeName,
       userTimeZone: input.userTimeZone,
       currentPage: input.currentPage,
+      chatSurface: input.chatSurface,
+      adminPublicOrigin: input.adminPublicOrigin,
       abortSignal: input.abortSignal,
       adminUser: input.adminUser,
       emit: input.emit,
@@ -408,6 +420,8 @@ export class AgentTurnService {
       modeName: input.modeName,
       userTimeZone: input.userTimeZone,
       currentPage: input.currentPage,
+      chatSurface: input.chatSurface,
+      adminPublicOrigin: input.adminPublicOrigin,
       abortSignal: input.abortSignal,
       adminUser: input.adminUser,
       emit: async (event) => {

package/build.log

@@ -62,5 +62,5 @@ custom/speech_recognition_frontend/voiceActivityDetection.ts
 custom/speech_recognition_frontend/types/
 custom/speech_recognition_frontend/types/voice-activity-detection.d.ts
 
-sent 1,668,700 bytes  received 921 bytes  3,339,242.00 bytes/sec
-total size is 1,664,547  speedup is 1.00
+sent 1,670,250 bytes  received 921 bytes  3,342,342.00 bytes/sec
+total size is 1,666,155  speedup is 1.00

package/chatSurfaceService.ts

@@ -184,6 +184,9 @@ export class ChatSurfaceService {
     options?: { emitDone?: boolean },
   ) {
     const emitDone = options?.emitDone ?? true;
+    const adminPublicOrigin = typeof incoming.metadata?.adminPublicOrigin === "string"
+      ? incoming.metadata.adminPublicOrigin
+      : undefined;
     const sessionId = await this.sessionStore.getOrCreateChatSurfaceSession(
       { ...incoming, prompt },
       adminUser,
@@ -195,6 +198,8 @@ export class ChatSurfaceService {
         sessionId,
         modeName: incoming.modeName,
         userTimeZone: incoming.userTimeZone ?? "UTC",
+        chatSurface: incoming.surface,
+        adminPublicOrigin,
         adminUser,
         emit: this.createEventEmitter(sink),
         failureLogMessage: `Agent ${incoming.surface} surface response failed`,
@@ -208,6 +213,8 @@ export class ChatSurfaceService {
       sessionId,
       modeName: incoming.modeName,
       userTimeZone: incoming.userTimeZone ?? "UTC",
+      chatSurface: incoming.surface,
+      adminPublicOrigin,
       adminUser,
       emit: this.createEventEmitter(sink),
       failureLogMessage: `Agent ${incoming.surface} surface response failed`,

package/custom/composables/agentStore/useAgentChat.ts

@@ -13,11 +13,13 @@ type AgentImportMeta = ImportMeta & {
 type CreateAgentChatManagerOptions = {
   lastMessage: Ref<string>;
   activeModeName: Ref<string | null>;
+  onOpenPage: (targetPath: string) => void;
 };
 
 export function createAgentChatManager({
   lastMessage,
   activeModeName,
+  onOpenPage,
 }: CreateAgentChatManagerOptions) {
   const chats = new Map<string, Chat<any>>();
   const currentChat = shallowRef<Chat<any> | null>();
@@ -52,6 +54,11 @@ export function createAgentChatManager({
         onError(error: unknown) {
           console.error('Chat error:', error);
         },
+        onData(dataPart: any) {
+          if (dataPart?.type === 'data-open-page' && typeof dataPart.data?.targetPath === 'string') {
+            onOpenPage(dataPart.data.targetPath);
+          }
+        },
       });
       chats.set(sessionId, newChat);
       currentChat.value = newChat;
@@ -67,4 +74,4 @@ export function createAgentChatManager({
     setCurrentChat,
     abortCurrentChatRequest,
   };
-}
+}

package/custom/composables/useAgentAudio.ts

@@ -187,6 +187,11 @@ export const useAgentAudio = defineStore('agentAudio', () => {
         playStandByAudio();
       }
       agentStore.addDataToolCallMessage(event.data);
+      return;
+    }
+
+    if (event.type === 'open-page') {
+      agentStore.openAgentPage(event.data.targetPath);
     }
   }
 

package/custom/composables/useAgentStore.ts

@@ -1,6 +1,7 @@
 import { defineStore } from 'pinia';
 import { IAgentSession, ISessionsListItem } from '../types';
 import { ref, nextTick, computed, watch, onMounted } from 'vue';
+import { useRouter } from 'vue-router';
 import { useAdminforth } from '@/adminforth';
 import { useCoreStore } from '@/stores/core';
 import { useAgentTransitions } from './useAgentTransitions';
@@ -28,6 +29,7 @@ export const useAgentStore = defineStore('agent', () => {
   const adminforth = useAdminforth();
   const isChatOpen = ref(false);
   const isSessionHistoryOpen = ref(false);
+  const router = useRouter();
   const textInput = ref<HTMLTextAreaElement | null>(null);
   const userMessageInput = ref();
   const trimmedUserMessage = computed(() => userMessageInput.value ? userMessageInput.value.trim() : '');
@@ -54,6 +56,7 @@ export const useAgentStore = defineStore('agent', () => {
   } = createAgentChatManager({
     lastMessage,
     activeModeName,
+    onOpenPage: openAgentPage,
   });
   const {
     userMessagePlaceholder,
@@ -324,6 +327,45 @@ export const useAgentStore = defineStore('agent', () => {
     addSystemMessage(RESERVED_SYSTEM_MESSAGE_CONTENT.AGENT_RESPONSE_ABORTED);
   }
 
+  function resolveInternalRoute(href: string): string | null {
+    if (href.startsWith('#')) {
+      return `${window.location.pathname}${window.location.search}${href}`;
+    }
+
+    if (href.startsWith('//')) {
+      return null;
+    }
+
+    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;
+    }
+
+    return `${resolvedUrl.pathname}${resolvedUrl.search}${resolvedUrl.hash}`;
+  }
+
+  function openAgentPage(targetPath: string) {
+    const internalRoute = resolveInternalRoute(targetPath);
+
+    if (internalRoute === null) {
+      console.warn('Ignoring external agent navigation target:', targetPath);
+      return;
+    }
+
+    if (isFullScreen.value && !coreStore.isMobile) {
+      setFullScreen(false);
+    } else if (coreStore.isMobile) {
+      setIsChatOpen(false);
+    }
+
+    void router.push(internalRoute);
+  }
+
   return {
     //_________-Sessions management-_____________
     activeSessionId,
@@ -374,6 +416,7 @@ export const useAgentStore = defineStore('agent', () => {
     addAgentMessage,
     addUserMessage,
     addDataToolCallMessage,
+    openAgentPage,
     setCurrentChatStatus,
     updateLastAgentMessage
   }

package/custom/tsconfig.json

@@ -1,6 +1,5 @@
 {
   "compilerOptions": {
-    "baseUrl": ".", // This should point to your project root
     "paths": {
       "@/*": [
         "../node_modules/adminforth/dist/spa/src/*"