@adminforth/agent 1.49.3 → 1.50.1

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,943 bytes  received 921 bytes  3,343,728.00 bytes/sec
+total size is 1,666,790  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/skills/fetch_data/SKILL.md

@@ -24,6 +24,8 @@ If several rows look similar, do not guess which one is "the same" record. Show
 
 For long texts show only several first words and add "..." at the end (only if user did not request this field specifically).
 
+Never show information about more than 10 records in one message. If a tool returns more than 10 relevant records, summarize the total count if known, show only the 10 most relevant records, and offer to narrow filters, sort differently, or continue with the next 10.
+
 Also when you communicate with user about record, add related link to this record. Build it as `{ADMIN_BASE_PATH}resource/{resourceId}/show/{primary key}`. Use _label from `get_resource_data` as anchor text for link (use markdown link). Links should always be relative paths and must start with `ADMIN_BASE_PATH`. Do not add an extra slash after `ADMIN_BASE_PATH`.
 
 Before sending the link, verify that the `resourceId`, `{primary key}`, `_label`, and shown fields come from the same exact returned row.