@roomle/embedding-lib 8.2.0 → 9.0.0-alpha.2

package/hi.js

@@ -65,10 +65,118 @@ var n = (e, t) => t === e.libraryId ? e : {
 	}, window.addEventListener("message", h);
 }, _ = () => {
 	h &&= (window.removeEventListener("message", h), null);
-}, v = {
+}, v = async (e) => (await import("./hi-mcp-server-DTQnrykg.mjs")).createHiMcpTools(e), y = (e) => `https://esm.sh/${e}?deps=zod@4.6.5`, b = 16, x = async ({ provider: e, model: t, apiKey: n, baseUrl: r, chatCompletions: i, reasoningEffort: a }) => {
+	switch (e) {
+		case "azure": {
+			let { createAzure: e } = await import(
+				/* @vite-ignore */
+				y("@ai-sdk/azure@4.0.85")
+), o = e({
+				apiKey: n,
+				baseURL: r
+			});
+			return {
+				languageModel: i ? o.chat(t) : o(t),
+				providerOptions: a ? { azure: { reasoningEffort: a } } : void 0
+			};
+		}
+		case "mistral": {
+			let { createMistral: e } = await import(
+				/* @vite-ignore */
+				y("@ai-sdk/mistral@4.0.54")
+);
+			return { languageModel: e({ apiKey: n })(t) };
+		}
+		case "anthropic": {
+			let { createAnthropic: e } = await import(
+				/* @vite-ignore */
+				y("@ai-sdk/anthropic@4.0.68")
+);
+			return { languageModel: e({
+				apiKey: n,
+				headers: { "anthropic-dangerous-direct-browser-access": "true" }
+			})(t) };
+		}
+		case "google": {
+			let { createGoogleGenerativeAI: e } = await import(
+				/* @vite-ignore */
+				y("@ai-sdk/google@4.0.85")
+);
+			return { languageModel: e({ apiKey: n })(t) };
+		}
+		default: throw Error(`Unknown provider "${e}" - supported: azure, mistral, anthropic, google`);
+	}
+}, S = async (e, t, n) => {
+	let r = e.extended, i = (e) => r.planningAssistantOutput(e), a;
+	try {
+		a = await Promise.all([
+			import(
+				/* @vite-ignore */
+				y("ai@7.0.122")
+),
+			x(t),
+			r.getExternalObjectAgentPrompts(),
+			v(e)
+		]);
+	} catch (e) {
+		console.log("[planning-assistant]", String(e)), i({
+			type: "availability",
+			available: !1,
+			text: String(e)
+		});
+		return;
+	}
+	let [{ streamText: o, stepCountIs: s }, c, l, u] = a, d = [];
+	r.callbacks.onPlanningAssistantPrompt = async ({ text: e, images: t }) => {
+		let r = {
+			role: "user",
+			content: [{
+				type: "text",
+				text: e || l.imagePrompt
+			}, ...t.map((e) => ({
+				type: "file",
+				data: e,
+				mediaType: "image/jpeg"
+			}))]
+		};
+		try {
+			let e = o({
+				model: c.languageModel,
+				providerOptions: c.providerOptions,
+				instructions: l.systemPrompt,
+				messages: [...d, r],
+				tools: u,
+				stopWhen: s(b),
+				abortSignal: n,
+				prepareStep: ({ stepNumber: e }) => e === b - 1 ? { toolChoice: "none" } : void 0
+			});
+			for await (let t of e.stream) if (t.type === "text-delta") i({
+				type: "text",
+				text: t.text
+			});
+			else if (t.type === "tool-call") i({
+				type: "activity",
+				text: t.toolName
+			});
+			else if (t.type === "error") throw t.error;
+			d.push(r, ...await e.responseMessages), i({ type: "done" });
+		} catch (e) {
+			console.log("[planning-assistant]", String(e)), i({
+				type: "error",
+				text: `The planning assistant failed: ${e instanceof Error ? e.message : String(e)}`
+			});
+		}
+	}, i({
+		type: "images",
+		enabled: t.readsImages
+	}), i({
+		type: "availability",
+		available: !0
+	});
+}, C = {
 	HIDE: "hide",
 	SHOW_ATTRIBUTES: "attributes",
 	SHOW_ARTICLES: "articles"
 };
 //#endregion
-export { v as HI_PANEL_ACTION, _ as cleanupHi, d as createHiLibraryCallbacks, c as libLoadArticleCatalog, u as libLoadCalcScript, l as libLoadMasterData, p as omGetRequest, f as omPostRequest, a as registerLegacyUrlFormat, g as setupHi, o as unregisterLegacyUrlFormat };
+export { C as HI_PANEL_ACTION, _ as cleanupHi, d as createHiLibraryCallbacks, v as createHiMcpTools, c as libLoadArticleCatalog, u as libLoadCalcScript, l as libLoadMasterData, x as loadChatModel, p as omGetRequest, f as omPostRequest, a as registerLegacyUrlFormat, g as setupHi, S as startPlanningAssistant, o as unregisterLegacyUrlFormat };

package/hi.min.js

@@ -66,9 +66,102 @@ var n = (e, t) => t === e.libraryId ? e : {
 	}, window.addEventListener("message", m);
 }, g = () => {
 	m &&= (window.removeEventListener("message", m), null);
-}, _ = {
+}, _ = async (e) => (await import("./hi-mcp-server-BiZlFkBm.mjs")).createHiMcpTools(e), v = (e) => `https://esm.sh/${e}?deps=zod@4.6.5`, y = async ({ provider: e, model: t, apiKey: n, baseUrl: r, chatCompletions: i, reasoningEffort: a }) => {
+	switch (e) {
+		case "azure": {
+			let { createAzure: e } = await import(v("@ai-sdk/azure@4.0.85")), o = e({
+				apiKey: n,
+				baseURL: r
+			});
+			return {
+				languageModel: i ? o.chat(t) : o(t),
+				providerOptions: a ? { azure: { reasoningEffort: a } } : void 0
+			};
+		}
+		case "mistral": {
+			let { createMistral: e } = await import(v("@ai-sdk/mistral@4.0.54"));
+			return { languageModel: e({ apiKey: n })(t) };
+		}
+		case "anthropic": {
+			let { createAnthropic: e } = await import(v("@ai-sdk/anthropic@4.0.68"));
+			return { languageModel: e({
+				apiKey: n,
+				headers: { "anthropic-dangerous-direct-browser-access": "true" }
+			})(t) };
+		}
+		case "google": {
+			let { createGoogleGenerativeAI: e } = await import(v("@ai-sdk/google@4.0.85"));
+			return { languageModel: e({ apiKey: n })(t) };
+		}
+		default: throw Error(`Unknown provider "${e}" - supported: azure, mistral, anthropic, google`);
+	}
+}, b = async (e, t, n) => {
+	let r = e.extended, i = (e) => r.planningAssistantOutput(e), a;
+	try {
+		a = await Promise.all([
+			import(v("ai@7.0.122")),
+			y(t),
+			r.getExternalObjectAgentPrompts(),
+			_(e)
+		]);
+	} catch (e) {
+		i({
+			type: "availability",
+			available: !1,
+			text: String(e)
+		});
+		return;
+	}
+	let [{ streamText: o, stepCountIs: s }, c, l, u] = a, d = [];
+	r.callbacks.onPlanningAssistantPrompt = async ({ text: e, images: t }) => {
+		let r = {
+			role: "user",
+			content: [{
+				type: "text",
+				text: e || l.imagePrompt
+			}, ...t.map((e) => ({
+				type: "file",
+				data: e,
+				mediaType: "image/jpeg"
+			}))]
+		};
+		try {
+			let e = o({
+				model: c.languageModel,
+				providerOptions: c.providerOptions,
+				instructions: l.systemPrompt,
+				messages: [...d, r],
+				tools: u,
+				stopWhen: s(16),
+				abortSignal: n,
+				prepareStep: ({ stepNumber: e }) => e === 15 ? { toolChoice: "none" } : void 0
+			});
+			for await (let t of e.stream) if (t.type === "text-delta") i({
+				type: "text",
+				text: t.text
+			});
+			else if (t.type === "tool-call") i({
+				type: "activity",
+				text: t.toolName
+			});
+			else if (t.type === "error") throw t.error;
+			d.push(r, ...await e.responseMessages), i({ type: "done" });
+		} catch (e) {
+			i({
+				type: "error",
+				text: `The planning assistant failed: ${e instanceof Error ? e.message : String(e)}`
+			});
+		}
+	}, i({
+		type: "images",
+		enabled: t.readsImages
+	}), i({
+		type: "availability",
+		available: !0
+	});
+}, x = {
 	HIDE: "hide",
 	SHOW_ATTRIBUTES: "attributes",
 	SHOW_ARTICLES: "articles"
 };
-export { _ as HI_PANEL_ACTION, g as cleanupHi, d as createHiLibraryCallbacks, c as libLoadArticleCatalog, u as libLoadCalcScript, l as libLoadMasterData, p as omGetRequest, f as omPostRequest, a as registerLegacyUrlFormat, h as setupHi, o as unregisterLegacyUrlFormat };
+export { x as HI_PANEL_ACTION, g as cleanupHi, d as createHiLibraryCallbacks, _ as createHiMcpTools, c as libLoadArticleCatalog, u as libLoadCalcScript, l as libLoadMasterData, y as loadChatModel, p as omGetRequest, f as omPostRequest, a as registerLegacyUrlFormat, h as setupHi, b as startPlanningAssistant, o as unregisterLegacyUrlFormat };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@roomle/embedding-lib",
-  "version": "8.2.0",
+  "version": "9.0.0-alpha.2",
   "description": "This is a small library which can be used to communicate with the Roomle Configurator. ES modules only (browser-compatible).",
   "type": "module",
   "main": "./roomle-embedding-lib.js",

package/packages/embedding-lib/src/hi.d.ts

@@ -14,5 +14,9 @@ export { createHiLibraryCallbacks } from './homag-intelligence/hi-callbacks';
 export { libLoadArticleCatalog, libLoadMasterData, libLoadCalcScript, registerLegacyUrlFormat, unregisterLegacyUrlFormat, } from './homag-intelligence/hi-requests';
 export { omPostRequest, omGetRequest, } from './homag-intelligence/hi-order-manager';
 export { setupHi, cleanupHi } from './homag-intelligence/hi-setup';
+export { createHiMcpTools } from './homag-intelligence/hi-mcp-tools';
+export type { HiMcpTool, HiMcpTools, } from './homag-intelligence/hi-mcp/mcp-tool-types';
+export type { HiMcpPlannerApi } from './homag-intelligence/hi-mcp/planner-api';
+export { loadChatModel, startPlanningAssistant, type PlanningAssistantConfig, type PlanningAssistantPlannerApi, } from './homag-intelligence/hi-planning-assistant';
 export { type ExternalObjectSnapshotSaveResult, type HiContextAction, } from '../../web-sdk/packages';
 export { HI_PANEL_ACTION, type HiPanelActionType, type HiOrderHeader, type HiOrder, type HiOrderData, type HiPriceData, type HiCallbacks, } from '../../common/src/hi/hi-types';

package/packages/embedding-lib/src/homag-intelligence/hi-mcp/agent-facing.d.ts

@@ -0,0 +1,35 @@
+type WallSide = 'left' | 'right' | 'top' | 'bottom';
+interface DerivedWall {
+    index: number;
+    side: WallSide;
+    start: [number, number, number];
+    end: [number, number, number];
+    lengthMm: number;
+    type?: string;
+    thicknessMm?: number;
+    facingRotationY: number;
+}
+export declare const wallName: (side: WallSide) => string;
+export interface RoomCorner {
+    name: string;
+    point: [number, number, number];
+    posRotationY: number;
+}
+export declare const roomCorners: (walls: DerivedWall[]) => RoomCorner[];
+export declare const spanAlongWall: (wall: DerivedWall, points: [number, number][]) => [number, number];
+export interface WallOfOpening {
+    roomIndex: number;
+    wall: number;
+    fromEndMm: [number, number];
+}
+export declare const wallOfOpening: (outline: [number, number][], rooms: {
+    walls?: DerivedWall[];
+}[]) => WallOfOpening | undefined;
+export declare const withSharedSelectionsOnce: (attributes: any[]) => any[];
+export declare const agentFacingAttributes: (masterData: any) => {
+    [k: string]: any[];
+};
+export declare const agentFacingArticle: (article: any) => any;
+export declare const agentFacingRooms: (rooms: any) => any;
+export declare const agentFacingObstacles: (obstacles: any, rooms: any) => any;
+export {};

package/packages/embedding-lib/src/homag-intelligence/hi-mcp/hi-mcp-server.d.ts

@@ -0,0 +1,3 @@
+import { HiMcpTools } from './mcp-tool-types';
+import { HiMcpPlannerApi } from './planner-api';
+export declare const createHiMcpTools: (roomDesignerApi: HiMcpPlannerApi) => HiMcpTools;

package/packages/embedding-lib/src/homag-intelligence/hi-mcp/mcp-tool-types.d.ts

@@ -0,0 +1,57 @@
+/** The result of a tool as an MCP server answers `tools/call`. */
+export interface McpToolResult {
+    content: ({
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image';
+        data: string;
+        mimeType: string;
+    })[];
+    isError?: boolean;
+}
+/** What the model gets of a tool result, as `@ai-sdk/mcp` hands it to the AI SDK. */
+export interface HiMcpModelOutput {
+    type: 'content';
+    value: ({
+        type: 'text';
+        text: string;
+    } | {
+        type: 'file';
+        mediaType: string;
+        data: {
+            type: 'data';
+            data: string;
+        };
+    })[];
+}
+/** The input schema of a tool as a Standard Schema with its JSON Schema. */
+export interface HiMcpInputSchema {
+    '~standard': {
+        version: 1;
+        vendor: string;
+        validate: (value: unknown) => {
+            value: unknown;
+        };
+        jsonSchema: {
+            input: (options: {
+                target: string;
+            }) => Record<string, unknown>;
+            output: (options: {
+                target: string;
+            }) => Record<string, unknown>;
+        };
+    };
+}
+/** A tool of the HI MCP tool set, in the shape of an AI SDK dynamic tool. */
+export interface HiMcpTool {
+    type: 'dynamic';
+    description: string;
+    inputSchema: HiMcpInputSchema;
+    execute: (input: unknown) => Promise<McpToolResult>;
+    toModelOutput: (options: {
+        output: McpToolResult;
+    }) => HiMcpModelOutput;
+}
+/** The HI MCP tools by name, the tool set an AI SDK `streamText` takes. */
+export type HiMcpTools = Record<string, HiMcpTool>;

package/packages/embedding-lib/src/homag-intelligence/hi-mcp/mcp-tool.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { HiMcpModelOutput, HiMcpTool, McpToolResult } from './mcp-tool-types';
+/** The tool result as `@ai-sdk/mcp` passes it to the model: text parts and images as file parts. */
+export declare const mcpToModelOutput: ({ output, }: {
+    output: McpToolResult;
+}) => HiMcpModelOutput;
+/**
+ * A tool as an MCP server registers it and an MCP client hands it to the AI
+ * SDK: the JSON Schema the MCP SDK serves, which the AI SDK does not validate;
+ * the input validated here, an invalid input and a thrown error answered as
+ * MCP error results, which the model reads like any other result.
+ */
+export declare const mcpTool: (name: string, description: string, shape: z.ZodRawShape, handler: (args: any) => Promise<McpToolResult>) => HiMcpTool;

package/packages/embedding-lib/src/homag-intelligence/hi-mcp/plan-history.d.ts

@@ -0,0 +1,33 @@
+/** A tool call that changed the plan, as the undo tool reverts it. */
+export interface ToolCallRecord {
+    tool: string;
+    /** The planner steps the call put on the planner's undo history. */
+    steps: number;
+    /** The plan's groups before and after the call, as comparison keys. */
+    groupsBefore: string;
+    groupsAfter: string;
+}
+export declare class PlanHistory {
+    private _events;
+    private _inFlight;
+    private _done;
+    private _undone;
+    private _changedInPlanner;
+    private _waiters;
+    get events(): number;
+    get changedInPlanner(): boolean;
+    historyChanged(): void;
+    /** Resolves true once `count` events have arrived, false after the timeout. */
+    waitForEvents(count: number, timeoutMs: number): Promise<boolean>;
+    begin(): void;
+    end(): void;
+    /** A new change on top of the history ends redo, as in the planner. */
+    record(call: ToolCallRecord): void;
+    lastDone(): ToolCallRecord | undefined;
+    lastUndone(): ToolCallRecord | undefined;
+    markUndone(): void;
+    markRedone(): void;
+    forget(): void;
+    /** A change in the planner was found: no record can be trusted any more. */
+    markChangedInPlanner(): void;
+}

package/packages/embedding-lib/src/homag-intelligence/hi-mcp/planner-api.d.ts

@@ -0,0 +1,32 @@
+export declare const DEFAULT_CALL_TIMEOUT_MS = 30000;
+export declare const SNAPSHOT_CALL_TIMEOUT_MS = 120000;
+export interface PlannerApi {
+    extended: {
+        getExternalObjectPlanContext(include: string[], options?: {
+            interiorDesign: {
+                groupId: string;
+                rootId?: string;
+                containerModuleId?: string;
+                articleId?: string;
+            };
+        }): Promise<any>;
+        externalObjectGroupOperation(command: string, payload: Record<string, unknown>): Promise<any>;
+        fetchPrice(): Promise<any>;
+        getExternalObjectSnapshot(options: Record<string, boolean>): Promise<any>;
+        undo(): Promise<void>;
+        redo(): Promise<void>;
+    };
+}
+/**
+ * The planner API a host hands to the HI MCP tools: the six planner methods
+ * the tools call, and the planner's callbacks, whose `onHistoryChange` the
+ * tools chain to tell their own planner steps from the user's changes.
+ */
+export type HiMcpPlannerApi = PlannerApi & {
+    extended: {
+        callbacks: {
+            onHistoryChange?: (undo: boolean, redo: boolean) => void;
+        };
+    };
+};
+export declare const createPlannerApi: ({ extended }: PlannerApi) => PlannerApi;

package/packages/embedding-lib/src/homag-intelligence/hi-mcp/skills.d.ts

@@ -0,0 +1,23 @@
+/** A frontmatter field as YAML reads it: a scalar, or a nested field (metadata) as an object of scalars. */
+export type FrontmatterValue = string | Record<string, string>;
+/** A planning skill in the Agent Skills format: a directory with SKILL.md and supporting files. */
+export interface Skill {
+    name: string;
+    description: string;
+    frontmatter: Record<string, FrontmatterValue>;
+    /** The text of every file of the skill by its path in the skill's directory. */
+    texts: Record<string, string>;
+    files: string[];
+}
+export declare const SKILL_FILE = "SKILL.md";
+/**
+ * Reads every skill of the skills directory, given as the text of each file by
+ * its path below the directory; a broken skill fails the load and names its
+ * file.
+ */
+export declare const loadSkills: (files: Record<string, string>) => Skill[];
+/** One line per skill: its name and its description. */
+export declare const skillIndex: (skills: Skill[]) => string;
+/** A file of a skill by its path; only a file of the skill's list is read. */
+export declare const readSkillFile: (skills: Skill[], name: string, file?: string) => string;
+export declare const skills: Skill[];

package/packages/embedding-lib/src/homag-intelligence/hi-mcp/tool-executors.d.ts

@@ -0,0 +1,4 @@
+import { PlanHistory } from './plan-history';
+import { PlannerApi } from './planner-api';
+export type ToolExecutor = (roomDesignerApi: PlannerApi, args: Record<string, unknown>) => Promise<unknown>;
+export declare const createToolExecutors: (planHistory: PlanHistory) => Record<string, ToolExecutor>;

package/packages/embedding-lib/src/homag-intelligence/hi-mcp-tools.d.ts

@@ -0,0 +1,11 @@
+import { HiMcpTools } from './hi-mcp/mcp-tool-types';
+import { HiMcpPlannerApi } from './hi-mcp/planner-api';
+/**
+ * Creates the HI MCP tools for an AI agent that plans in the planner of this
+ * page: the tools of the HI MCP server as an AI SDK tool set, without the MCP
+ * protocol. The host passes the tool set as `tools` to its own `streamText`.
+ * The tools call the planner through `roomDesignerApi.extended` and chain its
+ * `onHistoryChange` callback; a host that sets its own handler sets it before.
+ * The tool code is loaded on the first call.
+ */
+export declare const createHiMcpTools: (roomDesignerApi: HiMcpPlannerApi) => Promise<HiMcpTools>;

package/packages/embedding-lib/src/homag-intelligence/hi-planning-assistant.d.ts

@@ -0,0 +1,55 @@
+import { PlanningAssistantOutput, PlanningAssistantPrompt } from '../../../web-sdk/packages';
+import { HiMcpPlannerApi } from './hi-mcp/planner-api';
+/**
+ * The model of the AI Planning Assistant as a JSON object: everything
+ * `loadChatModel` and `startPlanningAssistant` need to reach it.
+ */
+export interface PlanningAssistantConfig {
+    /** `azure` for a deployment on an Azure AI Foundry resource, else the provider of the model. */
+    provider: 'azure' | 'mistral' | 'anthropic' | 'google';
+    /** The model id at the provider; for `azure` the name of the deployment. */
+    model: string;
+    /** The API key of the provider; for `azure` the key of the Foundry resource. */
+    apiKey: string;
+    /** `azure` only: the OpenAI v1 endpoint of the Foundry resource, e.g. `https://<resource>.services.ai.azure.com/openai/v1`. */
+    baseUrl?: string;
+    /** `azure` only: call the deployment through the Chat Completions API instead of the Responses API. */
+    chatCompletions?: boolean;
+    /** `azure` only: the reasoning effort of the deployment; its default when unset. */
+    reasoningEffort?: string;
+    /** Whether the model reads images: the window offers the image drop only then. */
+    readsImages: boolean;
+}
+/** The planner the planning assistant runs in: the HI MCP tools' planner API, the agent prompts and the window. */
+export type PlanningAssistantPlannerApi = HiMcpPlannerApi & {
+    extended: {
+        getExternalObjectAgentPrompts(): Promise<{
+            systemPrompt: string;
+            imagePrompt: string;
+        }>;
+        planningAssistantOutput(part: PlanningAssistantOutput): unknown;
+        callbacks: {
+            onPlanningAssistantPrompt?: (prompt: PlanningAssistantPrompt) => Promise<void>;
+        };
+    };
+};
+/** The AI SDK language model of the config and the provider options `streamText` takes with it. */
+export declare const loadChatModel: ({ provider, model, apiKey, baseUrl, chatCompletions, reasoningEffort, }: PlanningAssistantConfig) => Promise<{
+    languageModel: any;
+    providerOptions: {
+        azure: {
+            reasoningEffort: string;
+        };
+    };
+} | {
+    languageModel: any;
+    providerOptions?: undefined;
+}>;
+/**
+ * Runs the planning agent of the AI Planning Assistant window
+ * (featureFlags.planningAssistant) in this page: the window hands every
+ * message to "onPlanningAssistantPrompt", the agent calls the HI MCP tools,
+ * the tools call the planner of this page, and the agent's output goes to
+ * "planningAssistantOutput". Aborting the signal ends a running turn.
+ */
+export declare const startPlanningAssistant: (roomDesignerApi: PlanningAssistantPlannerApi, config: PlanningAssistantConfig, signal: AbortSignal) => Promise<void>;