@adminforth/agent 1.49.3 → 1.50.0

package/custom/types.ts

@@ -93,6 +93,12 @@ export type SpeechStreamEvent =
       type: 'data-tool-call';
       data: any;
     }
+  | {
+      type: 'open-page';
+      data: {
+        targetPath: string;
+      };
+    }
   | {
       type: 'finish';
     };

package/dist/agent/middleware/sequenceDebug.d.ts

@@ -16,6 +16,9 @@ export type SequenceDebug = {
     reasoningTokens: number;
     text: string;
     textTokens: number;
+    uncachedInputTokens: number;
+    cachedInputTokens: number;
+    outputTokens: number;
     cachedTokens: number;
     responseId: string | null;
     toolCalls: SequenceDebugToolCall[];
@@ -28,6 +31,9 @@ type SequenceDebugModelCall = {
     reasoningTokens: number;
     text: string;
     textTokens: number;
+    uncachedInputTokens: number;
+    cachedInputTokens: number;
+    outputTokens: number;
     cachedTokens: number;
     responseId: string | null;
     resultType: SequenceDebugResultType;

package/dist/agent/middleware/sequenceDebug.js

@@ -30,6 +30,9 @@ function createPendingSequenceDebug(sequenceId) {
         reasoningTokens: 0,
         text: "",
         textTokens: 0,
+        uncachedInputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0,
         cachedTokens: 0,
         responseId: null,
         toolCalls: [],
@@ -55,6 +58,9 @@ function finalizeSequenceDebug(sequence) {
         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((_a) => {
@@ -68,6 +74,18 @@ function finalizeSequenceDebug(sequence) {
 function getDebugModelName(model) {
     return typeof model.getName === "function" ? model.getName() : undefined;
 }
+function getDebugToolName(tool) {
+    if (!tool || typeof tool !== "object") {
+        return null;
+    }
+    const name = tool.name;
+    return typeof name === "string" ? name : null;
+}
+function formatToolsForDebug(tools) {
+    return tools.map((tool) => ({
+        name: getDebugToolName(tool),
+    }));
+}
 function stringifyPromptForDebug(params) {
     var _a, _b, _c;
     const { model, systemMessage, messages, tools, toolChoice, modelSettings } = params;
@@ -79,7 +97,7 @@ function stringifyPromptForDebug(params) {
             provider: (_c = (_b = model._defaultConfig) === null || _b === void 0 ? void 0 : _b.modelProvider) !== null && _c !== void 0 ? _c : null,
             configuredModel: typeof model.model === "string" ? model.model : null,
         }, systemMessage,
-        messages }, (tools.length > 0 ? { tools } : {})), (toolChoice !== undefined ? { toolChoice } : {})), (modelSettings ? { modelSettings } : {})), (invocationParams ? { invocationParams } : {})));
+        messages }, (tools.length > 0 ? { tools: formatToolsForDebug(tools) } : {})), (toolChoice !== undefined ? { toolChoice } : {})), (modelSettings ? { modelSettings } : {})), (invocationParams ? { invocationParams } : {})));
 }
 function getMessageBlocks(message) {
     if (Array.isArray(message.contentBlocks)) {
@@ -115,7 +133,10 @@ function countTokens(model, content) {
     });
 }
 function extractSequenceResponseDebug(message) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f;
+    const usageMetadata = message.usage_metadata;
+    const promptTokens = (_a = usageMetadata === null || usageMetadata === void 0 ? void 0 : usageMetadata.input_tokens) !== null && _a !== void 0 ? _a : 0;
+    const cachedInputTokens = (_c = (_b = usageMetadata === null || usageMetadata === void 0 ? void 0 : usageMetadata.input_token_details) === null || _b === void 0 ? void 0 : _b.cache_read) !== null && _c !== void 0 ? _c : 0;
     const blocks = getMessageBlocks(message);
     const reasoning = blocks
         .filter((block) => (block === null || block === void 0 ? void 0 : block.type) === "reasoning")
@@ -126,13 +147,16 @@ function extractSequenceResponseDebug(message) {
         .map((block) => { var _a; return String((_a = block.text) !== null && _a !== void 0 ? _a : ""); })
         .join("");
     return {
-        promptTokens: (_b = (_a = message.usage_metadata) === null || _a === void 0 ? void 0 : _a.input_tokens) !== null && _b !== void 0 ? _b : 0,
+        promptTokens,
         reasoning,
         reasoningTokens: 0,
         text: textFromBlocks || (typeof message.content === "string" ? message.content : ""),
         textTokens: 0,
-        cachedTokens: (_e = (_d = (_c = message.usage_metadata) === null || _c === void 0 ? void 0 : _c.input_token_details) === null || _d === void 0 ? void 0 : _d.cache_read) !== null && _e !== void 0 ? _e : 0,
-        responseId: (_g = (_f = message.response_metadata) === null || _f === void 0 ? void 0 : _f.id) !== null && _g !== void 0 ? _g : null,
+        uncachedInputTokens: Math.max(promptTokens - cachedInputTokens, 0),
+        cachedInputTokens,
+        outputTokens: (_d = usageMetadata === null || usageMetadata === void 0 ? void 0 : usageMetadata.output_tokens) !== null && _d !== void 0 ? _d : 0,
+        cachedTokens: cachedInputTokens,
+        responseId: (_f = (_e = message.response_metadata) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : null,
         resultType: hasToolCallSignal(message) ? "tool_calls" : "final_text",
     };
 }
@@ -171,6 +195,9 @@ export function createSequenceDebugCollector() {
             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;
@@ -244,7 +271,7 @@ export function createSequenceDebugMiddleware(sink) {
                 ]);
                 sink.handleModelCallComplete(Object.assign(Object.assign({}, debug), { promptTokens,
                     reasoningTokens,
-                    textTokens }));
+                    textTokens, uncachedInputTokens: debug.promptTokens ? debug.uncachedInputTokens : promptTokens, outputTokens: debug.outputTokens || reasoningTokens + textTokens }));
                 return response;
             });
         },

package/dist/agent/simpleAgent.d.ts

@@ -6,6 +6,7 @@ import { createSequenceDebugMiddleware, type SequenceDebugModelCallSink } from "
 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 declare const contextSchema: z.ZodObject<{
     adminUser: z.ZodCustom<AdminUser, AdminUser>;
     userTimeZone: z.ZodString;
@@ -13,7 +14,11 @@ export declare const contextSchema: z.ZodObject<{
     turnId: z.ZodString;
     abortSignal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
     currentPage: z.ZodOptional<z.ZodCustom<CurrentPageContext, CurrentPageContext>>;
+    chatSurface: z.ZodOptional<z.ZodString>;
+    adminBaseUrl: z.ZodOptional<z.ZodString>;
+    adminPublicOrigin: z.ZodOptional<z.ZodString>;
     emitToolCallEvent: z.ZodCustom<ToolCallEventSink, ToolCallEventSink>;
+    emitAgentEvent: z.ZodOptional<z.ZodCustom<AgentEventEmitter, AgentEventEmitter>>;
 }, z.core.$strip>;
 export type AgentChatModel = BaseChatModel<any, any>;
 export type AgentModelPurpose = "primary" | "summary";
@@ -54,9 +59,12 @@ export declare function callAgent(params: {
     sessionId: string;
     turnId: string;
     currentPage?: CurrentPageContext;
+    chatSurface?: string;
+    adminPublicOrigin?: string;
     userTimeZone: string;
     abortSignal?: AbortSignal;
     emitToolCallEvent: ToolCallEventSink;
+    emitAgentEvent?: AgentEventEmitter;
     sequenceDebugSink: SequenceDebugModelCallSink;
 }): Promise<import("@langchain/core/utils/stream").IterableReadableStream<[import("langchain").BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>, Record<string, any>]>>;
 export {};

package/dist/agent/simpleAgent.js

@@ -21,7 +21,11 @@ export const contextSchema = z.object({
     turnId: z.string(),
     abortSignal: z.custom().optional(),
     currentPage: z.custom().optional(),
+    chatSurface: z.string().optional(),
+    adminBaseUrl: z.string().optional(),
+    adminPublicOrigin: z.string().optional(),
     emitToolCallEvent: z.custom(),
+    emitAgentEvent: z.custom().optional(),
 });
 function isLangChainAgentCompletionAdapter(adapter) {
     return typeof adapter
@@ -132,7 +136,7 @@ export function createAgentChatModel(params) {
 }
 export function callAgent(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { name, model, summaryModel, modelMiddleware = [], checkpointer, messages, adminUser, adminforth, apiBasedTools, customComponentsDir, pluginCustomFolderPaths, sessionId, turnId, currentPage, userTimeZone, abortSignal, emitToolCallEvent, sequenceDebugSink, } = params;
+        const { name, model, summaryModel, modelMiddleware = [], checkpointer, messages, adminUser, adminforth, apiBasedTools, customComponentsDir, pluginCustomFolderPaths, sessionId, turnId, currentPage, chatSurface, adminPublicOrigin, userTimeZone, abortSignal, emitToolCallEvent, emitAgentEvent, sequenceDebugSink, } = params;
         const tools = yield createAgentTools(customComponentsDir, apiBasedTools, pluginCustomFolderPaths);
         const apiBasedToolsMiddleware = createApiBasedToolsMiddleware(apiBasedTools, adminforth);
         const sequenceDebugMiddleware = createSequenceDebugMiddleware(sequenceDebugSink);
@@ -169,7 +173,11 @@ export function callAgent(params) {
                 turnId,
                 abortSignal,
                 currentPage,
+                chatSurface,
+                adminBaseUrl: adminforth.config.baseUrlSlashed,
+                adminPublicOrigin,
                 emitToolCallEvent,
+                emitAgentEvent,
             },
         });
     });

package/dist/agent/systemPrompt.d.ts

@@ -7,5 +7,6 @@ export declare function buildAgentTurnSystemPrompt(input: {
     adminUser: AdminUser;
     usernameField: string;
     userLanguage: DetectedLanguage | null;
+    chatSurface?: string;
 }): string;
 export declare function buildAgentSystemPrompt(adminforth: IAdminForth, hiddenResourceIds?: Iterable<string>): Promise<string>;

package/dist/agent/systemPrompt.js

@@ -58,8 +58,11 @@ export function buildAgentTurnSystemPrompt(input) {
     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) {
     return resources
@@ -99,6 +102,7 @@ export function buildAgentSystemPrompt(adminforth_1) {
             "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.",
         ];
         return sections.filter(Boolean).join("\n\n");

package/dist/agent/tools/index.js

@@ -11,6 +11,7 @@ import { createFetchSkillTool } from "./fetchSkill.js";
 import { createFetchToolSchemaTool } from "./fetchToolSchema.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"];
 export function createAgentTools(customComponentsDir_1, apiBasedTools_1) {
     return __awaiter(this, arguments, void 0, function* (customComponentsDir, apiBasedTools, pluginCustomFolderPaths = []) {
@@ -23,6 +24,7 @@ export function createAgentTools(customComponentsDir_1, apiBasedTools_1) {
                 return createApiTool(toolName, apiBasedTool);
             }),
             createGetUserLocationTool(),
+            createNavigateUserTool(),
             yield createFetchSkillTool(customComponentsDir, pluginCustomFolderPaths),
             yield createFetchToolSchemaTool(apiBasedTools),
         ];

package/dist/agent/tools/navigateUser.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+export declare function createNavigateUserTool(): import("langchain").DynamicStructuredTool<z.ZodObject<{
+    targetPath: z.ZodOptional<z.ZodString>;
+    resourceId: z.ZodOptional<z.ZodString>;
+    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        list: "list";
+        show: "show";
+        edit: "edit";
+        create: "create";
+    }>>>;
+    recordId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        operator: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        column: z.ZodString;
+        direction: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>>;
+    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+}, z.core.$strip>, {
+    mode: "list" | "show" | "edit" | "create";
+    targetPath?: string | undefined;
+    resourceId?: string | undefined;
+    recordId?: string | number | undefined;
+    filters?: {
+        column: string;
+        operator: string;
+        value: unknown;
+    }[] | undefined;
+    sort?: {
+        column: string;
+        direction: "asc" | "desc";
+    } | undefined;
+    query?: Record<string, string | number | boolean> | undefined;
+}, {
+    targetPath?: string | undefined;
+    resourceId?: string | undefined;
+    mode?: "list" | "show" | "edit" | "create" | undefined;
+    recordId?: string | number | undefined;
+    filters?: {
+        column: string;
+        operator: string;
+        value: unknown;
+    }[] | undefined;
+    sort?: {
+        column: string;
+        direction: "asc" | "desc";
+    } | undefined;
+    query?: Record<string, string | number | boolean> | undefined;
+}, string, unknown, "navigate_user">;

package/dist/agent/tools/navigateUser.js

@@ -0,0 +1,163 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { tool } from "langchain";
+import { z } from "zod";
+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, currentPage) {
+    const trimmed = targetPath.trim();
+    if (!trimmed) {
+        throw new Error("targetPath cannot be empty.");
+    }
+    const currentOrigin = (currentPage === null || currentPage === void 0 ? void 0 : 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, params) {
+    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) {
+    var _a;
+    if (!input.resourceId) {
+        throw new Error("resourceId is required to build a resource route.");
+    }
+    const resourceId = encodeURIComponent(input.resourceId);
+    const mode = (_a = input.mode) !== null && _a !== void 0 ? _a : "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) {
+    var _a, _b;
+    const params = new URLSearchParams();
+    for (const filter of (_a = input.filters) !== null && _a !== void 0 ? _a : []) {
+        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((_b = input.query) !== null && _b !== void 0 ? _b : {})) {
+        params.set(key, String(value));
+    }
+    return params;
+}
+function buildSurfaceUrl(targetPath, adminBaseUrl, adminPublicOrigin) {
+    var _a;
+    const normalizedBasePath = (_a = adminBaseUrl === null || adminBaseUrl === void 0 ? void 0 : adminBaseUrl.replace(/\/+$/, "")) !== null && _a !== void 0 ? _a : "";
+    const normalizedTargetPath = targetPath.replace(/^\/+/, "");
+    const path = `${normalizedBasePath}/${normalizedTargetPath}`;
+    return adminPublicOrigin ? new URL(path, adminPublicOrigin).toString() : path;
+}
+export function createNavigateUserTool() {
+    return tool((input, runtime) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const context = runtime.context;
+        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);
+        }
+        yield ((_a = context.emitAgentEvent) === null || _a === void 0 ? void 0 : _a.call(context, {
+            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/dist/agentEvents.d.ts

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

package/dist/agentTurnService.d.ts

@@ -10,6 +10,8 @@ export type RunAndPersistAgentResponseInput = {
     modeName?: string | null;
     userTimeZone: string;
     currentPage?: CurrentPageContext;
+    chatSurface?: string;
+    adminPublicOrigin?: string;
     abortSignal?: AbortSignal;
     adminUser: AdminUser;
     emit?: AgentEventEmitter;

package/dist/agentTurnService.js

@@ -70,6 +70,7 @@ export class AgentTurnService {
                 adminUser: input.adminUser,
                 usernameField: adminforth.config.auth.usernameField,
                 userLanguage,
+                chatSurface: input.chatSurface,
             });
             const apiBasedTools = buildApiBasedTools(adminforth, this.serviceOptions.getInternalAgentResourceIds());
             const stream = yield callAgent({
@@ -90,6 +91,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) => {
@@ -100,6 +103,7 @@ export class AgentTurnService {
                         data: event,
                     }));
                 },
+                emitAgentEvent: input.emit,
                 sequenceDebugSink: input.sequenceDebugCollector,
             });
             try {
@@ -221,6 +225,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,
@@ -268,6 +274,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,
@@ -345,6 +353,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: (event) => __awaiter(this, void 0, void 0, function* () {

package/dist/chatSurfaceService.js

@@ -129,15 +129,20 @@ export class ChatSurfaceService {
     }
     handleAgentSurfaceResponse(incoming, sink, adminUser, prompt, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             const emitDone = (_a = options === null || options === void 0 ? void 0 : options.emitDone) !== null && _a !== void 0 ? _a : true;
+            const adminPublicOrigin = typeof ((_b = incoming.metadata) === null || _b === void 0 ? void 0 : _b.adminPublicOrigin) === "string"
+                ? incoming.metadata.adminPublicOrigin
+                : undefined;
             const sessionId = yield this.sessionStore.getOrCreateChatSurfaceSession(Object.assign(Object.assign({}, incoming), { prompt }), adminUser);
             if (emitDone) {
                 yield this.handleTurn({
                     prompt,
                     sessionId,
                     modeName: incoming.modeName,
-                    userTimeZone: (_b = incoming.userTimeZone) !== null && _b !== void 0 ? _b : "UTC",
+                    userTimeZone: (_c = incoming.userTimeZone) !== null && _c !== void 0 ? _c : "UTC",
+                    chatSurface: incoming.surface,
+                    adminPublicOrigin,
                     adminUser,
                     emit: this.createEventEmitter(sink),
                     failureLogMessage: `Agent ${incoming.surface} surface response failed`,
@@ -149,7 +154,9 @@ export class ChatSurfaceService {
                 prompt,
                 sessionId,
                 modeName: incoming.modeName,
-                userTimeZone: (_c = incoming.userTimeZone) !== null && _c !== void 0 ? _c : "UTC",
+                userTimeZone: (_d = incoming.userTimeZone) !== null && _d !== void 0 ? _d : "UTC",
+                chatSurface: incoming.surface,
+                adminPublicOrigin,
                 adminUser,
                 emit: this.createEventEmitter(sink),
                 failureLogMessage: `Agent ${incoming.surface} surface response failed`,

package/dist/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/dist/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);
     }
   }