alumnium 0.17.0 → 0.18.0

package/dist/Alumni.d.ts

@@ -13,6 +13,9 @@ export interface AlumniOptions {
     url?: string;
     model?: Model;
     extraTools?: ToolClass[];
+    planner?: boolean;
+    changeAnalysis?: boolean;
+    excludedAttributes?: Set<string>;
 }
 export interface VisionOptions {
     vision?: boolean;
@@ -24,6 +27,7 @@ export declare class Alumni {
     cache: Cache;
     private url;
     private model;
+    private changeAnalysis;
     constructor(driver: WebDriver | Page | Browser, options?: AlumniOptions);
     quit(): Promise<void>;
     do(goal: string): Promise<DoResult>;

package/dist/Alumni.js

@@ -20,11 +20,15 @@ import { BaseTool } from "./tools/BaseTool.js";
 import { getLogger } from "./utils/logger.js";
 import { retry } from "./utils/retry.js";
 const logger = getLogger(["Alumni"]);
+const changeAnalysis = (process.env.ALUMNIUM_CHANGE_ANALYSIS || "false").toLowerCase() === "true";
+const planner = (process.env.ALUMNIUM_PLANNER || "true").toLowerCase() === "true";
+const excludedAttributes = new Set((process.env.ALUMNIUM_EXCLUDE_ATTRIBUTES || "").split(",").filter(Boolean));
 export class Alumni {
     constructor(driver, options = {}) {
         this.tools = {};
         this.url = options.url || "http://localhost:8013";
         this.model = options.model || Model.current;
+        this.changeAnalysis = options.changeAnalysis ?? changeAnalysis;
         // Wrap driver or use directly if already wrapped
         if (driver instanceof WebDriver) {
             this.driver = new SeleniumDriver(driver);
@@ -47,7 +51,7 @@ export class Alumni {
             this.tools[tool.name] = tool;
         }
         // Initialize HTTP client
-        this.client = new HttpClient(this.url, this.model, this.driver.platform, this.tools);
+        this.client = new HttpClient(this.url, this.model, this.driver.platform, this.tools, options.planner ?? planner, options.excludedAttributes ?? excludedAttributes);
         this.cache = new Cache(this.client);
         logger.info(`Using model: ${this.model.provider}/${this.model.name}`);
         logger.info(`Using HTTP client with server: ${this.url}`);
@@ -57,8 +61,14 @@ export class Alumni {
         await this.driver.quit();
     }
     async do(goal) {
+        const app = await this.driver.app();
         const initialAccessibilityTree = await this.driver.getAccessibilityTree();
-        const { explanation, steps } = await this.client.planActions(goal, initialAccessibilityTree.toStr());
+        const beforeTree = this.changeAnalysis
+            ? initialAccessibilityTree.toStr()
+            : null;
+        const beforeUrl = this.changeAnalysis ? await this.driver.url() : null;
+        const { explanation, steps } = await this.client.planActions(goal, initialAccessibilityTree.toStr(), app);
+        let finalExplanation = explanation;
         const executedSteps = [];
         for (let idx = 0; idx < steps.length; idx++) {
             const step = steps[idx];
@@ -66,22 +76,30 @@ export class Alumni {
             const accessibilityTree = idx === 0
                 ? initialAccessibilityTree
                 : await this.driver.getAccessibilityTree();
-            const actorResponse = await this.client.executeAction(goal, step, accessibilityTree.toStr());
+            const { explanation: actorExplanation, actions } = await this.client.executeAction(goal, step, accessibilityTree.toStr(), app);
+            // When planner is off, explanation is just the goal — replace with actor's reasoning.
+            if (finalExplanation === goal) {
+                finalExplanation = actorExplanation;
+            }
             const calledTools = [];
-            for (const toolCall of actorResponse) {
+            for (const toolCall of actions) {
                 const calledTool = await BaseTool.executeToolCall(toolCall, this.tools, this.driver);
                 calledTools.push(calledTool);
             }
             executedSteps.push({ name: step, tools: calledTools });
         }
-        return { explanation, steps: executedSteps };
+        let changes = "";
+        if (this.changeAnalysis && executedSteps.length > 0) {
+            changes = await this.client.analyzeChanges(beforeTree, beforeUrl, (await this.driver.getAccessibilityTree()).toStr(), await this.driver.url());
+        }
+        return { explanation: finalExplanation, steps: executedSteps, changes };
     }
     async check(statement, options = {}) {
         const screenshot = options.vision
             ? await this.driver.screenshot()
             : undefined;
         const accessibilityTree = await this.driver.getAccessibilityTree();
-        const [explanation, value] = await this.client.retrieve(`Is the following true or false - ${statement}`, accessibilityTree.toStr(), await this.driver.title(), await this.driver.url(), screenshot);
+        const [explanation, value] = await this.client.retrieve(`Is the following true or false - ${statement}`, accessibilityTree.toStr(), await this.driver.title(), await this.driver.url(), screenshot, await this.driver.app());
         if (!value) {
             throw new AssertionError(explanation);
         }
@@ -92,17 +110,17 @@ export class Alumni {
             ? await this.driver.screenshot()
             : undefined;
         const accessibilityTree = await this.driver.getAccessibilityTree();
-        const [explanation, value] = await this.client.retrieve(data, accessibilityTree.toStr(), await this.driver.title(), await this.driver.url(), screenshot);
+        const [explanation, value] = await this.client.retrieve(data, accessibilityTree.toStr(), await this.driver.title(), await this.driver.url(), screenshot, await this.driver.app());
         return value === null ? explanation : value;
     }
     async find(description) {
         const accessibilityTree = await this.driver.getAccessibilityTree();
-        const response = await this.client.findElement(description, accessibilityTree.toStr());
+        const response = await this.client.findElement(description, accessibilityTree.toStr(), await this.driver.app());
         return this.driver.findElement(response.id);
     }
     async area(description) {
         const accessibilityTree = await this.driver.getAccessibilityTree();
-        const response = await this.client.findArea(description, accessibilityTree.toStr());
+        const response = await this.client.findArea(description, accessibilityTree.toStr(), await this.driver.app());
         const scopedTree = accessibilityTree.scopeToArea(response.id);
         return new Area(response.id, response.explanation, scopedTree, this.driver, this.tools, this.client);
     }

package/dist/Area.js

@@ -20,24 +20,30 @@ export class Area {
         this.client = client;
     }
     async do(goal) {
-        const { explanation, steps } = await this.client.planActions(goal, this.accessibilityTree.toStr());
+        const app = await this.driver.app();
+        const { explanation, steps } = await this.client.planActions(goal, this.accessibilityTree.toStr(), app);
+        let finalExplanation = explanation;
         const executedSteps = [];
         for (const step of steps) {
-            const actorResponse = await this.client.executeAction(goal, step, this.accessibilityTree.toStr());
+            const { explanation: actorExplanation, actions } = await this.client.executeAction(goal, step, this.accessibilityTree.toStr(), app);
+            // When planner is off, explanation is just the goal — replace with actor's reasoning.
+            if (finalExplanation === goal) {
+                finalExplanation = actorExplanation;
+            }
             const calledTools = [];
-            for (const toolCall of actorResponse) {
+            for (const toolCall of actions) {
                 const calledTool = await BaseTool.executeToolCall(toolCall, this.tools, this.driver);
                 calledTools.push(calledTool);
             }
             executedSteps.push({ name: step, tools: calledTools });
         }
-        return { explanation, steps: executedSteps };
+        return { explanation: finalExplanation, steps: executedSteps, changes: "" };
     }
     async check(statement, options = {}) {
         const screenshot = options.vision
             ? await this.driver.screenshot()
             : undefined;
-        const [explanation, value] = await this.client.retrieve(`Is the following true or false - ${statement}`, this.accessibilityTree.toStr(), await this.driver.title(), await this.driver.url(), screenshot);
+        const [explanation, value] = await this.client.retrieve(`Is the following true or false - ${statement}`, this.accessibilityTree.toStr(), await this.driver.title(), await this.driver.url(), screenshot, await this.driver.app());
         if (!value) {
             throw new AssertionError(explanation);
         }
@@ -47,11 +53,11 @@ export class Area {
         const screenshot = options.vision
             ? await this.driver.screenshot()
             : undefined;
-        const [explanation, value] = await this.client.retrieve(data, this.accessibilityTree.toStr(), await this.driver.title(), await this.driver.url(), screenshot);
+        const [explanation, value] = await this.client.retrieve(data, this.accessibilityTree.toStr(), await this.driver.title(), await this.driver.url(), screenshot, await this.driver.app());
         return value === null ? explanation : value;
     }
     async find(description) {
-        const response = await this.client.findElement(description, this.accessibilityTree.toStr());
+        const response = await this.client.findElement(description, this.accessibilityTree.toStr(), await this.driver.app());
         return this.driver.findElement(response.id);
     }
 }

package/dist/Model.d.ts

@@ -1,4 +1,5 @@
 export declare enum Provider {
+    AZURE_FOUNDRY = "azure_foundry",
     AZURE_OPENAI = "azure_openai",
     ANTHROPIC = "anthropic",
     AWS_ANTHROPIC = "aws_anthropic",

package/dist/Model.js

@@ -1,5 +1,6 @@
 export var Provider;
 (function (Provider) {
+    Provider["AZURE_FOUNDRY"] = "azure_foundry";
     Provider["AZURE_OPENAI"] = "azure_openai";
     Provider["ANTHROPIC"] = "anthropic";
     Provider["AWS_ANTHROPIC"] = "aws_anthropic";
@@ -15,13 +16,14 @@ export var Provider;
 export class ModelName {
 }
 ModelName.DEFAULT = {
+    [Provider.AZURE_FOUNDRY]: "gpt-5-nano",
     [Provider.AZURE_OPENAI]: "gpt-5-nano",
     [Provider.ANTHROPIC]: "claude-haiku-4-5-20251001",
     [Provider.AWS_ANTHROPIC]: "us.anthropic.claude-haiku-4-5-20251001-v1:0",
     [Provider.AWS_META]: "us.meta.llama4-maverick-17b-instruct-v1:0",
     [Provider.DEEPSEEK]: "deepseek-reasoner",
     [Provider.GITHUB]: "gpt-4o-mini",
-    [Provider.GOOGLE]: "gemini-3-flash-preview",
+    [Provider.GOOGLE]: "gemini-3.1-flash-lite-preview",
     [Provider.MISTRALAI]: "mistral-medium-2505",
     [Provider.OLLAMA]: "mistral-small3.1",
     [Provider.OPENAI]: "gpt-5-nano-2025-08-07",

package/dist/accessibility/AccessibilityElement.d.ts

@@ -10,5 +10,8 @@ export declare class AccessibilityElement {
     androidText?: string;
     androidContentDesc?: string;
     androidBounds?: string;
-    constructor(id?: number, name?: string, label?: string, type?: string, value?: string, backendNodeId?: number, androidResourceId?: string, androidClass?: string, androidText?: string, androidContentDesc?: string, androidBounds?: string);
+    frame?: object;
+    locatorInfo?: Record<string, unknown>;
+    frameChain?: number[];
+    constructor(id?: number, name?: string, label?: string, type?: string, value?: string, backendNodeId?: number, androidResourceId?: string, androidClass?: string, androidText?: string, androidContentDesc?: string, androidBounds?: string, frame?: object, locatorInfo?: Record<string, unknown>, frameChain?: number[]);
 }

package/dist/accessibility/AccessibilityElement.js

@@ -1,5 +1,5 @@
 export class AccessibilityElement {
-    constructor(id, name, label, type, value, backendNodeId, androidResourceId, androidClass, androidText, androidContentDesc, androidBounds) {
+    constructor(id, name, label, type, value, backendNodeId, androidResourceId, androidClass, androidText, androidContentDesc, androidBounds, frame, locatorInfo, frameChain) {
         this.id = id;
         this.backendNodeId = backendNodeId;
         this.name = name;
@@ -11,5 +11,8 @@ export class AccessibilityElement {
         this.androidText = androidText;
         this.androidContentDesc = androidContentDesc;
         this.androidBounds = androidBounds;
+        this.frame = frame;
+        this.locatorInfo = locatorInfo;
+        this.frameChain = frameChain;
     }
 }

package/dist/accessibility/ChromiumAccessibilityTree.d.ts

@@ -4,11 +4,14 @@ export declare class ChromiumAccessibilityTree extends BaseAccessibilityTree {
     private cdpResponse;
     private nextRawId;
     private raw;
+    private frameMap;
+    private frameChainMap;
     constructor(cdpResponse: unknown);
     private static fromXml;
     toStr(): string;
     private nodeToXml;
     private elementToString;
+    private unescapeXml;
     elementById(rawId: number): AccessibilityElement;
     scopeToArea(rawId: number): ChromiumAccessibilityTree;
     private findElementByRawId;

package/dist/accessibility/ChromiumAccessibilityTree.js

@@ -5,11 +5,16 @@ export class ChromiumAccessibilityTree extends BaseAccessibilityTree {
         super();
         this.nextRawId = 0;
         this.raw = null;
+        this.frameMap = new Map();
+        this.frameChainMap = new Map(); // raw_id -> frame chain
         this.cdpResponse = cdpResponse;
     }
-    static fromXml(xmlString) {
+    static fromXml(xmlString, frameMap) {
         const instance = new ChromiumAccessibilityTree({ nodes: [] });
         instance.raw = xmlString;
+        if (frameMap) {
+            instance.frameMap = frameMap;
+        }
         return instance;
     }
     toStr() {
@@ -17,18 +22,38 @@ export class ChromiumAccessibilityTree extends BaseAccessibilityTree {
             return this.raw;
         }
         const nodes = this.cdpResponse.nodes;
+        if (!nodes || nodes.length === 0) {
+            this.raw = "";
+            return this.raw;
+        }
         const nodeLookup = {};
         for (const node of nodes) {
             nodeLookup[node.nodeId] = node;
         }
-        // Build tree structure and convert to XML
-        const rootNodes = [];
+        // Build mapping: backendDOMNodeId -> list of iframe child root nodes
+        // This allows us to inline iframe content inside their parent <Iframe> elements
+        const iframeChildren = new Map();
+        const trueRoots = [];
         for (const node of nodes) {
             if (!node.parentId) {
-                const xmlNode = this.nodeToXml(node, nodeLookup);
-                rootNodes.push(xmlNode);
+                const parentIframeId = node._parent_iframe_backend_node_id;
+                if (parentIframeId !== undefined) {
+                    if (!iframeChildren.has(parentIframeId)) {
+                        iframeChildren.set(parentIframeId, []);
+                    }
+                    iframeChildren.get(parentIframeId).push(node);
+                }
+                else {
+                    trueRoots.push(node);
+                }
             }
         }
+        // Build tree structure and convert to XML (only from true roots)
+        const rootNodes = [];
+        for (const node of trueRoots) {
+            const xmlNode = this.nodeToXml(node, nodeLookup, iframeChildren);
+            rootNodes.push(xmlNode);
+        }
         // Combine all root nodes into a single XML string
         let xmlString = "";
         for (const root of rootNodes) {
@@ -37,7 +62,7 @@ export class ChromiumAccessibilityTree extends BaseAccessibilityTree {
         this.raw = xmlString;
         return this.raw;
     }
-    nodeToXml(node, nodeLookup) {
+    nodeToXml(node, nodeLookup, iframeChildren) {
         const role = node.role?.value || "unknown";
         const elem = {
             tag: role,
@@ -47,6 +72,24 @@ export class ChromiumAccessibilityTree extends BaseAccessibilityTree {
         // Add our own sequential raw_id attribute
         this.nextRawId++;
         elem.attributes.raw_id = String(this.nextRawId);
+        // Store frame reference if present
+        if (node._frame) {
+            this.frameMap.set(this.nextRawId, node._frame);
+        }
+        // Store frame chain if present (for Selenium nested frame switching)
+        if (node._frame_chain) {
+            this.frameChainMap.set(this.nextRawId, node._frame_chain);
+        }
+        // Store Playwright node metadata
+        if (node._playwright_node) {
+            elem.attributes._playwright_node = "true";
+        }
+        if (node._locator_info) {
+            elem.attributes._locator_info = JSON.stringify(node._locator_info);
+        }
+        if (node._frame_url) {
+            elem.attributes._frame_url = node._frame_url;
+        }
         // Add all node attributes as XML attributes
         if (node.backendDOMNodeId !== undefined) {
             elem.attributes.backendDOMNodeId = String(node.backendDOMNodeId);
@@ -84,11 +127,19 @@ export class ChromiumAccessibilityTree extends BaseAccessibilityTree {
         if (node.childIds) {
             for (const childId of node.childIds) {
                 if (childId in nodeLookup) {
-                    const childElem = this.nodeToXml(nodeLookup[childId], nodeLookup);
+                    const childElem = this.nodeToXml(nodeLookup[childId], nodeLookup, iframeChildren);
                     elem.children.push(childElem);
                 }
             }
         }
+        // Inline iframe content: if this element is an iframe, add its child trees
+        const backendNodeId = node.backendDOMNodeId;
+        if (backendNodeId !== undefined && iframeChildren.has(backendNodeId)) {
+            for (const childRoot of iframeChildren.get(backendNodeId)) {
+                const childElem = this.nodeToXml(childRoot, nodeLookup, iframeChildren);
+                elem.children.push(childElem);
+            }
+        }
         return elem;
     }
     elementToString(elem, indent) {
@@ -124,17 +175,39 @@ export class ChromiumAccessibilityTree extends BaseAccessibilityTree {
         }
         return result;
     }
+    unescapeXml(value) {
+        return value
+            .replace(/&apos;/g, "'")
+            .replace(/&quot;/g, '"')
+            .replace(/&gt;/g, ">")
+            .replace(/&lt;/g, "<")
+            .replace(/&amp;/g, "&");
+    }
     elementById(rawId) {
         const rawXml = this.toStr();
         const element = this.findElementByRawId(rawXml, rawId);
         if (!element) {
             throw new Error(`No element with raw_id=${rawId} found`);
         }
+        // Handle Playwright nodes (cross-origin iframes)
+        if (element.attributes._playwright_node === "true") {
+            // Synthetic frame node
+            if (element.attributes._frame_url) {
+                return new AccessibilityElement(undefined, undefined, undefined, element.tag, undefined, undefined, undefined, undefined, undefined, undefined, undefined, this.frameMap.get(rawId), { _synthetic_frame: true, _frame_url: element.attributes._frame_url });
+            }
+            // Regular Playwright node with locator info
+            const locatorInfo = element.attributes
+                ._locator_info
+                ? JSON.parse(element.attributes._locator_info)
+                : {};
+            return new AccessibilityElement(undefined, undefined, undefined, element.tag, undefined, undefined, undefined, undefined, undefined, undefined, undefined, this.frameMap.get(rawId), locatorInfo);
+        }
+        // Existing CDP node logic
         const backendNodeIdStr = element.attributes.backendDOMNodeId;
         if (!backendNodeIdStr) {
             throw new Error(`Element with raw_id=${rawId} has no backendDOMNodeId attribute`);
         }
-        return new AccessibilityElement(undefined, undefined, undefined, element.tag, undefined, parseInt(backendNodeIdStr));
+        return new AccessibilityElement(undefined, undefined, undefined, element.tag, undefined, parseInt(backendNodeIdStr), undefined, undefined, undefined, undefined, undefined, this.frameMap.get(rawId), undefined, this.frameChainMap.get(rawId));
     }
     scopeToArea(rawId) {
         const rawXml = this.toStr();
@@ -143,7 +216,7 @@ export class ChromiumAccessibilityTree extends BaseAccessibilityTree {
             return this;
         }
         const scopedXml = this.elementToString(element, 0);
-        return ChromiumAccessibilityTree.fromXml(scopedXml);
+        return ChromiumAccessibilityTree.fromXml(scopedXml, this.frameMap);
     }
     findElementByRawId(xmlString, targetRawId) {
         // Parse the XML string to find the element
@@ -195,6 +268,10 @@ export class ChromiumAccessibilityTree extends BaseAccessibilityTree {
                 while ((attrMatch = attrRegex.exec(attrsString)) !== null) {
                     attributes[attrMatch[1]] = attrMatch[2];
                 }
+                // Unescape XML entities in attribute values
+                for (const key of Object.keys(attributes)) {
+                    attributes[key] = this.unescapeXml(attributes[key]);
+                }
                 const elem = {
                     tag: tagName,
                     attributes,

package/dist/clients/ApiModels.d.ts

@@ -11,6 +11,8 @@ export interface SessionRequest {
     tools: {
         [key: string]: any;
     }[];
+    planner?: boolean;
+    excluded_attributes?: string[];
 }
 export interface SessionResponse {
     session_id: string;
@@ -20,6 +22,7 @@ export interface PlanRequest {
     accessibility_tree: string;
     url?: string;
     title?: string;
+    app?: string;
 }
 export interface PlanResponse {
     explanation: string;
@@ -29,8 +32,10 @@ export interface StepRequest {
     goal: string;
     step: string;
     accessibility_tree: string;
+    app?: string;
 }
 export interface StepResponse {
+    explanation: string;
     actions: {
         [key: string]: any;
     }[];
@@ -41,6 +46,7 @@ export interface StatementRequest {
     url?: string;
     title?: string;
     screenshot?: string | null;
+    app?: string;
 }
 export interface StatementResponse {
     result: string | string[];
@@ -49,6 +55,7 @@ export interface StatementResponse {
 export interface AreaRequest {
     description: string;
     accessibility_tree: string;
+    app?: string;
 }
 export interface AreaResponse {
     id: number;
@@ -57,6 +64,7 @@ export interface AreaResponse {
 export interface FindRequest {
     description: string;
     accessibility_tree: string;
+    app?: string;
 }
 export interface FindResponse {
     elements: {
@@ -67,6 +75,17 @@ export interface AddExampleRequest {
     goal: string;
     actions: string[];
 }
+export interface ChangeState {
+    accessibility_tree: string;
+    url: string;
+}
+export interface ChangesRequest {
+    before: ChangeState;
+    after: ChangeState;
+}
+export interface ChangesResponse {
+    result: string;
+}
 export interface StatsResponse {
     [key: string]: {
         [key: string]: number;

package/dist/clients/HttpClient.d.ts

@@ -6,27 +6,33 @@ export declare class HttpClient {
     private model;
     private platform;
     private tools;
+    private planner;
+    private excludedAttributes;
     private baseUrl;
     private sessionId;
     private sessionPromise;
     private timeout;
-    constructor(baseUrl: string, model: Model, platform: string, tools: Record<string, ToolClass>);
+    constructor(baseUrl: string, model: Model, platform: string, tools: Record<string, ToolClass>, planner?: boolean, excludedAttributes?: Set<string>);
     private fetchWithTimeout;
     private ensureSession;
     quit(): Promise<void>;
-    planActions(goal: string, accessibilityTree: string): Promise<{
+    planActions(goal: string, accessibilityTree: string, app?: string): Promise<{
         explanation: string;
         steps: string[];
     }>;
     addExample(goal: string, actions: string[]): Promise<void>;
     clearExamples(): Promise<void>;
-    executeAction(goal: string, step: string, accessibilityTree: string): Promise<StepResponse["actions"]>;
-    retrieve(statement: string, accessibilityTree: string, title: string, url: string, screenshot?: string): Promise<[string, Data]>;
-    findArea(description: string, accessibilityTree: string): Promise<{
+    executeAction(goal: string, step: string, accessibilityTree: string, app?: string): Promise<{
+        explanation: string;
+        actions: StepResponse["actions"];
+    }>;
+    retrieve(statement: string, accessibilityTree: string, title: string, url: string, screenshot?: string, app?: string): Promise<[string, Data]>;
+    findArea(description: string, accessibilityTree: string, app?: string): Promise<{
         id: number;
         explanation: string;
     }>;
-    findElement(description: string, accessibilityTree: string): Promise<FindResponse["elements"][0]>;
+    findElement(description: string, accessibilityTree: string, app?: string): Promise<FindResponse["elements"][0]>;
+    analyzeChanges(beforeAccessibilityTree: string, beforeUrl: string, afterAccessibilityTree: string, afterUrl: string): Promise<string>;
     saveCache(): Promise<void>;
     discardCache(): Promise<void>;
     getStats(): Promise<StatsResponse>;

package/dist/clients/HttpClient.js

@@ -3,10 +3,12 @@ import { getLogger } from "../utils/logger.js";
 import { looselyTypecast } from "./typecasting.js";
 const logger = getLogger(["HttpClient"]);
 export class HttpClient {
-    constructor(baseUrl, model, platform, tools) {
+    constructor(baseUrl, model, platform, tools, planner = true, excludedAttributes = new Set()) {
         this.model = model;
         this.platform = platform;
         this.tools = tools;
+        this.planner = planner;
+        this.excludedAttributes = excludedAttributes;
         this.sessionId = null;
         this.sessionPromise = null;
         this.timeout = 300000; // 5 minutes
@@ -34,6 +36,8 @@ export class HttpClient {
                     name: this.model.name,
                     platform: this.platform,
                     tools: toolSchemas,
+                    planner: this.planner,
+                    excluded_attributes: [...this.excludedAttributes],
                 };
                 const response = await this.fetchWithTimeout(`${this.baseUrl}/v1/sessions`, {
                     method: "POST",
@@ -57,11 +61,12 @@ export class HttpClient {
             this.sessionId = null;
         }
     }
-    async planActions(goal, accessibilityTree) {
+    async planActions(goal, accessibilityTree, app = "unknown") {
         await this.ensureSession();
         const requestBody = {
             goal,
             accessibility_tree: accessibilityTree,
+            app,
         };
         const response = await this.fetchWithTimeout(`${this.baseUrl}/v1/sessions/${this.sessionId}/plans`, {
             method: "POST",
@@ -93,12 +98,13 @@ export class HttpClient {
             method: "DELETE",
         });
     }
-    async executeAction(goal, step, accessibilityTree) {
+    async executeAction(goal, step, accessibilityTree, app = "unknown") {
         await this.ensureSession();
         const requestBody = {
             goal,
             step,
             accessibility_tree: accessibilityTree,
+            app,
         };
         const response = await this.fetchWithTimeout(`${this.baseUrl}/v1/sessions/${this.sessionId}/steps`, {
             method: "POST",
@@ -108,9 +114,12 @@ export class HttpClient {
             body: JSON.stringify(requestBody),
         });
         const responseData = (await response.json());
-        return responseData.actions;
+        return {
+            explanation: responseData.explanation,
+            actions: responseData.actions,
+        };
     }
-    async retrieve(statement, accessibilityTree, title, url, screenshot) {
+    async retrieve(statement, accessibilityTree, title, url, screenshot, app = "unknown") {
         await this.ensureSession();
         const requestBody = {
             statement,
@@ -118,6 +127,7 @@ export class HttpClient {
             title,
             url,
             screenshot: screenshot || null,
+            app,
         };
         const response = await this.fetchWithTimeout(`${this.baseUrl}/v1/sessions/${this.sessionId}/statements`, {
             method: "POST",
@@ -129,11 +139,12 @@ export class HttpClient {
         const responseData = (await response.json());
         return [responseData.explanation, looselyTypecast(responseData.result)];
     }
-    async findArea(description, accessibilityTree) {
+    async findArea(description, accessibilityTree, app = "unknown") {
         await this.ensureSession();
         const requestBody = {
             description,
             accessibility_tree: accessibilityTree,
+            app,
         };
         const response = await this.fetchWithTimeout(`${this.baseUrl}/v1/sessions/${this.sessionId}/areas`, {
             method: "POST",
@@ -145,11 +156,12 @@ export class HttpClient {
         const responseData = (await response.json());
         return { id: responseData.id, explanation: responseData.explanation };
     }
-    async findElement(description, accessibilityTree) {
+    async findElement(description, accessibilityTree, app = "unknown") {
         await this.ensureSession();
         const requestBody = {
             description,
             accessibility_tree: accessibilityTree,
+            app,
         };
         const response = await this.fetchWithTimeout(`${this.baseUrl}/v1/sessions/${this.sessionId}/elements`, {
             method: "POST",
@@ -161,6 +173,22 @@ export class HttpClient {
         const responseData = (await response.json());
         return responseData.elements[0];
     }
+    async analyzeChanges(beforeAccessibilityTree, beforeUrl, afterAccessibilityTree, afterUrl) {
+        await this.ensureSession();
+        const requestBody = {
+            before: { accessibility_tree: beforeAccessibilityTree, url: beforeUrl },
+            after: { accessibility_tree: afterAccessibilityTree, url: afterUrl },
+        };
+        const response = await this.fetchWithTimeout(`${this.baseUrl}/v1/sessions/${this.sessionId}/changes`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(requestBody),
+        });
+        const responseData = (await response.json());
+        return responseData.result;
+    }
     async saveCache() {
         await this.ensureSession();
         await this.fetchWithTimeout(`${this.baseUrl}/v1/sessions/${this.sessionId}/caches`, {