@trilogy-data/trilogy-studio-components 0.1.28 → 0.1.30

package/dist/entry.agent.d.ts

@@ -0,0 +1,12 @@
+export { LLMProvider } from './llm/base';
+export type { LLMMessage, LLMRequestOptions, LLMResponse, LLMToolCall, LLMToolResult, LLMToolDefinition, RateLimitBackoffCallback, } from './llm/base';
+export { AnthropicProvider, parseAnthropicModelVersion, compareAnthropicModels, } from './llm/anthropic';
+export { OpenAIProvider } from './llm/openai';
+export { OpenRouterProvider } from './llm/openrouter';
+export { DeepSeekProvider, parseDeepSeekModel, compareDeepSeekModels } from './llm/deepseek';
+export { runToolLoop, providerAdapter, formatToolResultText, stripPromptWrapperTags, SYSTEM_INPUT_START, SYSTEM_INPUT_END, } from './llm/toolLoopCore';
+export type { LLMAdapter, MessagePersistence, ToolExecutorFactory, ExecutionStateUpdater, ToolLoopConfig, ToolLoopResult, } from './llm/toolLoopCore';
+export { RETURN_TO_USER_TOOL } from './llm/returnToUserTool';
+export type { ToolCallResult } from './llm/sharedToolHelpers';
+export type { ChatMessage, ChatArtifact, ChatToolCall } from './chats/chat';
+//# sourceMappingURL=entry.agent.d.ts.map

package/dist/entry.agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.agent.d.ts","sourceRoot":"","sources":["../entry.agent.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACxC,YAAY,EACV,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,WAAW,EACX,aAAa,EACb,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,iBAAiB,EACjB,0BAA0B,EAC1B,sBAAsB,GACvB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAC5F,OAAO,EACL,WAAW,EACX,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,oBAAoB,CAAA;AAC3B,YAAY,EACV,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,cAAc,EACd,cAAc,GACf,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAC5D,YAAY,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC7D,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA"}

package/dist/entry.llm.d.ts

@@ -1,5 +1,5 @@
 export * from './llm/index';
-export { runToolLoop } from './llm/toolLoopCore';
+export { runToolLoop, providerAdapter } from './llm/toolLoopCore';
 export type { LLMAdapter, MessagePersistence, ToolExecutorFactory, ExecutionStateUpdater, ToolLoopConfig, ToolLoopResult, } from './llm/toolLoopCore';
 export type { ChatMessage, ChatSessionData, ChatArtifact } from './chats';
 //# sourceMappingURL=entry.llm.d.ts.map

package/dist/entry.llm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry.llm.d.ts","sourceRoot":"","sources":["../entry.llm.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,YAAY,EACV,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,cAAc,EACd,cAAc,GACf,MAAM,oBAAoB,CAAA;AAC3B,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"entry.llm.d.ts","sourceRoot":"","sources":["../entry.llm.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACjE,YAAY,EACV,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,cAAc,EACd,cAAc,GACf,MAAM,oBAAoB,CAAA;AAC3B,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA"}

package/dist/{freemarker2-DQBqlEXc.js → freemarker2-ZGcKAI8o.js}

@@ -1,4 +1,4 @@
-import { p as e } from "./workers-B9Eybl-M.js";
+import { p as e } from "./workers-CHvkad0r.js";
 //#region node_modules/.pnpm/monaco-editor@0.55.1/node_modules/monaco-editor/esm/vs/basic-languages/freemarker2/freemarker2.js
 var t = [
 	"assign",

package/dist/{globalChatRuntime-DAERmOdu.js → globalChatRuntime-BnMYNYqe.js}

@@ -1,8 +1,8 @@
-import { t as e } from "./screenBridge-BLlMdfhn.js";
-import { K as t, X as n, Z as r, ct as i, et as a } from "./llm-Wf4Etiu9.js";
-import { a as o, d as s } from "./stores-DTGQZ4_B.js";
-import { a as c, r as l } from "./editorStore-CiWH_nGN.js";
-import { t as u } from "./useGlobalChatPanel-D9kMZLeF.js";
+import { Q as e, Z as t, lt as n, nt as r, q as i } from "./llm-Bc1CfjOE.js";
+import { t as a } from "./screenBridge-BLlMdfhn.js";
+import { a as o, r as s } from "./editorStore-Czhpct1j.js";
+import { a as c, d as l } from "./stores-DgdADCiH.js";
+import { t as u } from "./useGlobalChatPanel-Doeilj18.js";
 import { watch as d } from "vue";
 //#region llm/registry/renderToolList.ts
 function f(e) {
@@ -15,7 +15,7 @@ function f(e) {
 //#region llm/navigationContextInjector.ts
 var p = 1500, m = /* @__PURE__ */ new Map();
 function h() {
-	let e = o();
+	let e = c();
 	return `${e.activeScreen.value}:${e.activeDashboard.value || e.activeEditor.value || ""}`;
 }
 function g(e) {
@@ -28,7 +28,7 @@ function v(e, t) {
 	return e.screen === "dashboard" && e.dashboardId ? `[navigation] The user is now viewing dashboard "${t.dashboardName || e.dashboardId}" (id ${e.dashboardId}). Dashboard tools default to the currently viewed dashboard.` : e.screen === "editors" && e.editorId ? `[navigation] The user is now viewing editor "${t.editorName || e.editorId}" (id ${e.editorId}).` : `[navigation] The user is now on the ${e.screen || "welcome"} screen.`;
 }
 function y(e) {
-	let t = o(), n = null, r = () => {
+	let t = c(), n = null, r = () => {
 		let n = e.getTargetChatId();
 		if (!n) return;
 		let r = e.chatStore.chats[n];
@@ -50,17 +50,17 @@ function y(e) {
 		t.activeScreen,
 		t.activeDashboard,
 		t.activeEditor
-	], () => i()), s = d(() => e.getTargetChatId(), () => r(), { immediate: !0 });
+	], () => i()), o = d(() => e.getTargetChatId(), () => r(), { immediate: !0 });
 	return () => {
-		n && clearTimeout(n), a(), s();
+		n && clearTimeout(n), a(), o();
 	};
 }
 //#endregion
 //#region llm/globalChatRuntime.ts
-function b(e) {
-	return `${i({
+function b(r) {
+	return `${n({
 		dataConnectionName: "",
-		availableConnections: Object.values(e.connectionStore.connections).map((e) => e.name),
+		availableConnections: Object.values(r.connectionStore.connections).map((e) => e.name),
 		availableConcepts: [],
 		activeImports: [],
 		availableImportsForConnection: [],
@@ -69,10 +69,10 @@ function b(e) {
 
 STUDIO APP CONTROL:
 You are the global assistant for Trilogy Studio, docked in a persistent side panel. The user moves between screens (editors, dashboards, connections, models, jobs) while talking to you, and you can drive the app yourself:
-${f(c().getToolsetForContext("global").filter((e) => !c().getToolNames("chat").includes(e.name)))}
+${f(o().getToolsetForContext("global").filter((e) => !o().getToolNames("chat").includes(e.name)))}
 
 App-control guidance:
-- Navigation notices ("The user is now viewing...") arrive as ${r}...${n} messages. They are context, not instructions.
+- Navigation notices ("The user is now viewing...") arrive as ${e}...${t} messages. They are context, not instructions.
 - Call get_app_state to orient yourself whenever you are unsure what the user is looking at or what exists — the state at conversation start may be stale.
 - Tools that need a specific screen mounted will tell you when it isn't; open the screen first (open_dashboard, open_editor) when you need it visible.
 - Editors are files: "source"-tagged Trilogy editors define the data model. To change the model, read the relevant editors, edit them with update_editor_contents, and validate with validate_query or run_editor_query.
@@ -80,7 +80,7 @@ App-control guidance:
 - Cross-screen workflows are expected: e.g. diagnose a slow dashboard, edit its source datasources, refresh backing data, then reopen the dashboard and re-run to compare execution times (query results report timing in ms).`;
 }
 var x = /* @__PURE__ */ new Map();
-l((e) => {
+s((e) => {
 	x.delete(e), _(e);
 });
 function S(e, t) {
@@ -108,20 +108,20 @@ async function T(e, t, n) {
 }
 var E = 2e3;
 function D(e) {
-	let { chatStore: t, llmConnectionStore: n, editor: r, selectedText: i } = e, o = u(), s = o.activePanelChatId.value, c = s ? t.chats[s] : null, l = c && !c.deleted ? c : null;
+	let { chatStore: t, llmConnectionStore: n, editor: i, selectedText: a } = e, o = u(), s = o.activePanelChatId.value, c = s ? t.chats[s] : null, l = c && !c.deleted ? c : null;
 	l ||= t.chatList.filter((e) => e.kind === "user" && e.source === "user").sort((e, t) => new Date(t.updatedAt).getTime() - new Date(e.updatedAt).getTime())[0] || null, l ||= t.newChat(n.activeConnection || "", "", void 0, "", { activate: !1 });
-	let d = i?.trim() ? a(i) : "", f = d ? `\nTheir current selection in that editor:\n${d.slice(0, E)}${d.length > E ? "\n...(selection truncated)" : ""}` : "";
-	return l.pendingContextNote = `[editor] The user asked for AI help from editor "${a(r.name)}" (id ${r.id}). Read it with read_editor before proposing or making changes; apply edits with update_editor_contents.${f}`, g(l.id), o.openPanel(l.id), l.id;
+	let d = a?.trim() ? r(a) : "", f = d ? `\nTheir current selection in that editor:\n${d.slice(0, E)}${d.length > E ? "\n...(selection truncated)" : ""}` : "";
+	return l.pendingContextNote = `[editor] The user asked for AI help from editor "${r(i.name)}" (id ${i.id}). Read it with read_editor before proposing or making changes; apply edits with update_editor_contents.${f}`, g(l.id), o.openPanel(l.id), l.id;
 }
-async function O(i) {
-	let { chatId: l, message: u, chatStore: d, deps: f } = i, p = d.chats[l];
+async function O(n) {
+	let { chatId: s, message: u, chatStore: d, deps: f } = n, p = d.chats[s];
 	if (!p) return;
-	(p.llmConnectionName || f.llmConnectionStore.activeConnection) && p.pendingContextNote && (d.addMessageToChat(l, {
+	(p.llmConnectionName || f.llmConnectionStore.activeConnection) && p.pendingContextNote && (d.addMessageToChat(s, {
 		role: "user",
-		content: `${r}${a(p.pendingContextNote)}${n}`,
+		content: `${e}${r(p.pendingContextNote)}${t}`,
 		hidden: !0
 	}), p.pendingContextNote = null);
-	let m = c(), h = {
+	let m = o(), h = {
 		connectionStore: f.connectionStore,
 		editorStore: f.editorStore,
 		chatStore: d,
@@ -129,25 +129,25 @@ async function O(i) {
 		...f.dashboardStore ? { dashboardStore: f.dashboardStore } : {},
 		...f.modelStore ? { modelStore: f.modelStore } : {},
 		llmConnectionStore: f.llmConnectionStore,
-		jobsStore: s(),
+		jobsStore: l(),
 		...f.saveEditors ? { saveEditors: f.saveEditors } : {},
 		...f.saveModels ? { saveModels: f.saveModels } : {},
-		navigation: o(),
-		screenBridge: e()
+		navigation: c(),
+		screenBridge: a()
 	}, g = m.createExecutor("global", h, {
-		chatId: l,
+		chatId: s,
 		cache: /* @__PURE__ */ new Map(),
 		requestCompaction: async (e) => {
-			let n = f.llmConnectionStore.connections[p.llmConnectionName || f.llmConnectionStore.activeConnection];
-			if (!n) return {
+			let t = f.llmConnectionStore.connections[p.llmConnectionName || f.llmConnectionStore.activeConnection];
+			if (!t) return {
 				success: !1,
 				error: "No LLM provider available for compaction."
 			};
 			try {
-				let r = await t(n, p, { focus: e });
-				return r ? {
+				let n = await i(t, p, { focus: e });
+				return n ? {
 					success: !0,
-					message: `Compacted ${r.archivedCount} earlier messages into a summary. The reduced history applies from the next turn.`
+					message: `Compacted ${n.archivedCount} earlier messages into a summary. The reduced history applies from the next turn.`
 				} : {
 					success: !0,
 					message: "The conversation is still small — nothing worth compacting yet."
@@ -160,11 +160,11 @@ async function O(i) {
 			}
 		}
 	});
-	await d.executeMessage(l, u, f, { overrides: {
+	await d.executeMessage(s, u, f, { overrides: {
 		tools: m.getToolsetForContext("global"),
 		executeToolCall: (e, t) => g.executeToolCall(e, t),
-		buildSystemPrompt: S(l, f)
-	} }), await T(l, d, f);
+		buildSystemPrompt: S(s, f)
+	} }), await T(s, d, f);
 }
 //#endregion
 export { y as a, _ as i, D as n, O as r, C as t };

package/dist/{handlebars-tgYxaM70.js → handlebars-B3s0Qrrb.js}

@@ -1,4 +1,4 @@
-import { p as e } from "./workers-B9Eybl-M.js";
+import { p as e } from "./workers-CHvkad0r.js";
 //#region node_modules/.pnpm/monaco-editor@0.55.1/node_modules/monaco-editor/esm/vs/basic-languages/handlebars/handlebars.js
 var t = [
 	"area",

package/dist/{helpers-C2pARJoZ.js → helpers-B3tq3RZK.js}

@@ -1,8 +1,8 @@
-import { s as e } from "./base-DuKnVD-A.js";
-import { It as t, gn as n } from "./llm-Wf4Etiu9.js";
-import "./stores-DTGQZ4_B.js";
-import { M as r, Y as i, at as a, tt as o } from "./editorStore-CiWH_nGN.js";
-import { n as s } from "./reconcile-BH_ReGDR.js";
+import { Rt as e } from "./llm-Bc1CfjOE.js";
+import { s as t } from "./base-DuKnVD-A.js";
+import { M as n, Y as r, _t as i, at as a, tt as o } from "./editorStore-Czhpct1j.js";
+import "./stores-DgdADCiH.js";
+import { n as s } from "./reconcile-DtPcgEjQ.js";
 //#region models/helpers.ts
 var c = class {
 	editorStore;
@@ -17,13 +17,13 @@ var c = class {
 	async fetchModelImportBase(e, t) {
 		let n = await fetch(e, this.buildRequestInit(t));
 		if (!n.ok) throw Error(`Failed to fetch model import from ${e}: ${n.statusText}`);
-		let r = await n.text(), a;
+		let i = await n.text(), a;
 		try {
-			a = JSON.parse(r);
+			a = JSON.parse(i);
 		} catch (t) {
 			throw Error(`Invalid JSON in model import from ${e}: ${t}`);
 		}
-		return i(a, e);
+		return r(a, e);
 	}
 	purposeToTag(e) {
 		switch (e) {
@@ -81,7 +81,7 @@ var c = class {
 		if (e.name?.trim()) return this.getRemoteEditorPath(e);
 		if (!t) return null;
 		try {
-			let n = `${r(t)}/`, i = new URL(n), a = new URL(e.url, i);
+			let r = `${n(t)}/`, i = new URL(r), a = new URL(e.url, i);
 			if (a.origin !== i.origin || !a.pathname.startsWith(i.pathname)) return null;
 			let o = a.pathname.slice(i.pathname.length);
 			return decodeURIComponent(o);
@@ -115,8 +115,8 @@ var c = class {
 			return;
 		}
 		try {
-			let o = t.fromSerialized(JSON.parse(n.content));
-			o.storage = "local", o.connection = r, o.connectionId = e({
+			let o = e.fromSerialized(JSON.parse(n.content));
+			o.storage = "local", o.connection = r, o.connectionId = t({
 				name: r,
 				storage: a.remote ? "remote" : "local",
 				remoteStoreId: a.remoteStoreId
@@ -132,18 +132,18 @@ var c = class {
 			console.error(`Error importing dashboard ${n.name}:`, e);
 		}
 	}
-	async importModel(e, t, r, i = {}) {
+	async importModel(e, t, n, r = {}) {
 		if (!t) return null;
 		let a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map();
 		try {
-			let l = await this.fetchModelImportBase(t, i.token), u = await this.fetchModelImports(l, i.token), d = u.filter((e) => e.type === "sql" || e.type === "trilogy" || e.type === "python"), f = u.filter((e) => e.type === "dashboard"), p = [];
+			let l = await this.fetchModelImportBase(t, r.token), u = await this.fetchModelImports(l, r.token), d = u.filter((e) => e.type === "sql" || e.type === "trilogy" || e.type === "python"), f = u.filter((e) => e.type === "dashboard"), p = [];
 			for (let e of d) {
 				console.log(`Processing editor: ${e.name}`);
-				let t = this.createOrUpdateEditor(e, r, i);
-				e.type === "sql" ? o.set(e.name, t.id) : e.type === "trilogy" ? (s.set(e.name, t.id), p.push(new n(t.id, e.alias || e.name, [], []))) : e.type === "python" && c.set(e.name, t.id);
+				let t = this.createOrUpdateEditor(e, n, r);
+				e.type === "sql" ? o.set(e.name, t.id) : e.type === "trilogy" ? (s.set(e.name, t.id), p.push(new i(t.id, e.alias || e.name, [], []))) : e.type === "python" && c.set(e.name, t.id);
 			}
-			for (let e of f) console.log(`Processing dashboard: ${e.name}`), this.createOrUpdateDashboard(e, r, a, i);
-			return this.modelStore.models[e].sources = p, this.modelStore.models[e].storage = i.remote ? "remote" : "local", this.modelStore.models[e].changed = !0, {
+			for (let e of f) console.log(`Processing dashboard: ${e.name}`), this.createOrUpdateDashboard(e, n, a, r);
+			return this.modelStore.models[e].sources = p, this.modelStore.models[e].storage = r.remote ? "remote" : "local", this.modelStore.models[e].changed = !0, {
 				dashboards: a,
 				sql: o,
 				trilogy: s,

package/dist/{html-jJahD3Mi.js → html-DM1koKCG.js}

@@ -1,4 +1,4 @@
-import { p as e } from "./workers-B9Eybl-M.js";
+import { p as e } from "./workers-CHvkad0r.js";
 //#region node_modules/.pnpm/monaco-editor@0.55.1/node_modules/monaco-editor/esm/vs/basic-languages/html/html.js
 var t = [
 	"area",

package/dist/{htmlMode-BA1-8l2e.js → htmlMode-CpPImbDh.js}

@@ -1,5 +1,5 @@
-import { p as e, t } from "./workers-B9Eybl-M.js";
-import { _ as n, a as r, c as i, d as a, f as o, g as s, h as c, i as l, l as u, m as d, n as f, o as p, p as m, r as h, s as g, t as _, u as v, v as y } from "./lspLanguageFeatures-V3e_p9oN.js";
+import { p as e, t } from "./workers-CHvkad0r.js";
+import { _ as n, a as r, c as i, d as a, f as o, g as s, h as c, i as l, l as u, m as d, n as f, o as p, p as m, r as h, s as g, t as _, u as v, v as y } from "./lspLanguageFeatures-GDtuGOTD.js";
 //#region node_modules/.pnpm/monaco-editor@0.55.1/node_modules/monaco-editor/esm/vs/language/html/workerManager.js
 var b = 12e4, x = class {
 	constructor(e) {

package/dist/{javascript-Cypfo7va.js → javascript-jClqu73w.js}

@@ -1,4 +1,4 @@
-import { conf as e, language as t } from "./typescript-BM-ynfk9.js";
+import { conf as e, language as t } from "./typescript-CzBSjjfY.js";
 //#region node_modules/.pnpm/monaco-editor@0.55.1/node_modules/monaco-editor/esm/vs/basic-languages/javascript/javascript.js
 var n = e, r = {
 	defaultToken: "invalid",

package/dist/{jsonMode-xJye8PWS.js → jsonMode-CwFYTPO9.js}

@@ -1,5 +1,5 @@
-import { d as e, p as t, t as n } from "./workers-B9Eybl-M.js";
-import { _ as r, a as i, c as a, d as o, f as s, g as c, h as l, i as u, l as d, m as f, n as p, o as m, p as h, r as g, s as _, t as v, u as y, v as b } from "./lspLanguageFeatures-V3e_p9oN.js";
+import { d as e, p as t, t as n } from "./workers-CHvkad0r.js";
+import { _ as r, a as i, c as a, d as o, f as s, g as c, h as l, i as u, l as d, m as f, n as p, o as m, p as h, r as g, s as _, t as v, u as y, v as b } from "./lspLanguageFeatures-GDtuGOTD.js";
 //#region node_modules/.pnpm/monaco-editor@0.55.1/node_modules/monaco-editor/esm/vs/language/json/workerManager.js
 var x = 12e4, S = class {
 	constructor(e) {

package/dist/{liquid-BGDrv5da.js → liquid-C6l-UINC.js}

@@ -1,4 +1,4 @@
-import { p as e } from "./workers-B9Eybl-M.js";
+import { p as e } from "./workers-CHvkad0r.js";
 //#region node_modules/.pnpm/monaco-editor@0.55.1/node_modules/monaco-editor/esm/vs/basic-languages/liquid/liquid.js
 var t = [
 	"area",

package/dist/llm/chatAgentPrompt.d.ts

@@ -1,6 +1,7 @@
 import { ModelConceptInput } from './data/models';
 import { ChatImport } from '../chats/chat';
 import { LLMToolDefinition } from './base';
+import { RETURN_TO_USER_TOOL } from './returnToUserTool';
 import { ToolCallResult } from './sharedToolHelpers';
 export interface TrilogyPromptContext {
     /** Complete syntax reference generated from pytrilogy's AI prompt. */
@@ -35,7 +36,8 @@ export interface TrilogyPromptContext {
  * ```
  */
 export declare function buildCustomTrilogyPrompt(templateFn: (ctx: TrilogyPromptContext) => string): string;
-export declare const RETURN_TO_USER_TOOL: {
+export { RETURN_TO_USER_TOOL };
+export declare const CHAT_TOOLS: ({
     readonly name: "return_to_user";
     readonly description: "Signal that you are done and return control to the user. You MUST call this tool when you have completed all requested tasks and are ready for the user's next input. Provide a brief summary of what was accomplished. Never end a turn with plain text — always call this tool when finished.";
     readonly input_schema: {
@@ -48,8 +50,7 @@ export declare const RETURN_TO_USER_TOOL: {
         };
         readonly required: readonly ["message"];
     };
-};
-export declare const CHAT_TOOLS: ({
+} | {
     readonly name: "connect_data_connection";
     readonly description: "Connect or reconnect a data connection that is not currently active. Use this when a query fails because the connection is not active, or when you need to establish a connection before running queries.";
     readonly input_schema: {
@@ -62,19 +63,6 @@ export declare const CHAT_TOOLS: ({
         };
         readonly required: readonly ["connection"];
     };
-} | {
-    readonly name: "return_to_user";
-    readonly description: "Signal that you are done and return control to the user. You MUST call this tool when you have completed all requested tasks and are ready for the user's next input. Provide a brief summary of what was accomplished. Never end a turn with plain text — always call this tool when finished.";
-    readonly input_schema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly message: {
-                readonly type: "string";
-                readonly description: "A brief summary of what was accomplished or a response to the user.";
-            };
-        };
-        readonly required: readonly ["message"];
-    };
 } | {
     name: string;
     description: string;

package/dist/llm/chatAgentPrompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chatAgentPrompt.d.ts","sourceRoot":"","sources":["../../llm/chatAgentPrompt.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"chatAgentPrompt.d.ts","sourceRoot":"","sources":["../../llm/chatAgentPrompt.ts"],"names":[],"mappings":"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"}

package/dist/llm/dashboardAgentRuntime.d.ts

@@ -32,30 +32,30 @@ export declare function ensureDashboardChat(dashboard: DashboardModel, chatStore
 /** Tools the agent receives. Reports get the report-mode tools layered onto
  *  the standard dashboard tool surface. */
 export declare function dashboardAgentToolset(dashboard: DashboardModel): ({
-    readonly name: "connect_data_connection";
-    readonly description: "Connect or reconnect a data connection that is not currently active. Use this when a query fails because the connection is not active, or when you need to establish a connection before running queries.";
+    readonly name: "return_to_user";
+    readonly description: "Signal that you are done and return control to the user. You MUST call this tool when you have completed all requested tasks and are ready for the user's next input. Provide a brief summary of what was accomplished. Never end a turn with plain text — always call this tool when finished.";
     readonly input_schema: {
         readonly type: "object";
         readonly properties: {
-            readonly connection: {
+            readonly message: {
                 readonly type: "string";
-                readonly description: "The name of the data connection to connect";
+                readonly description: "A brief summary of what was accomplished or a response to the user.";
             };
         };
-        readonly required: readonly ["connection"];
+        readonly required: readonly ["message"];
     };
 } | {
-    readonly name: "return_to_user";
-    readonly description: "Signal that you are done and return control to the user. You MUST call this tool when you have completed all requested tasks and are ready for the user's next input. Provide a brief summary of what was accomplished. Never end a turn with plain text — always call this tool when finished.";
+    readonly name: "connect_data_connection";
+    readonly description: "Connect or reconnect a data connection that is not currently active. Use this when a query fails because the connection is not active, or when you need to establish a connection before running queries.";
     readonly input_schema: {
         readonly type: "object";
         readonly properties: {
-            readonly message: {
+            readonly connection: {
                 readonly type: "string";
-                readonly description: "A brief summary of what was accomplished or a response to the user.";
+                readonly description: "The name of the data connection to connect";
             };
         };
-        readonly required: readonly ["message"];
+        readonly required: readonly ["connection"];
     };
 } | {
     name: string;

package/dist/llm/dashboardAgentTools.d.ts

@@ -3,30 +3,30 @@
  * These tools let the LLM read and modify a live dashboard.
  */
 export declare const DASHBOARD_TOOLS: ({
-    readonly name: "connect_data_connection";
-    readonly description: "Connect or reconnect a data connection that is not currently active. Use this when a query fails because the connection is not active, or when you need to establish a connection before running queries.";
+    readonly name: "return_to_user";
+    readonly description: "Signal that you are done and return control to the user. You MUST call this tool when you have completed all requested tasks and are ready for the user's next input. Provide a brief summary of what was accomplished. Never end a turn with plain text — always call this tool when finished.";
     readonly input_schema: {
         readonly type: "object";
         readonly properties: {
-            readonly connection: {
+            readonly message: {
                 readonly type: "string";
-                readonly description: "The name of the data connection to connect";
+                readonly description: "A brief summary of what was accomplished or a response to the user.";
             };
         };
-        readonly required: readonly ["connection"];
+        readonly required: readonly ["message"];
     };
 } | {
-    readonly name: "return_to_user";
-    readonly description: "Signal that you are done and return control to the user. You MUST call this tool when you have completed all requested tasks and are ready for the user's next input. Provide a brief summary of what was accomplished. Never end a turn with plain text — always call this tool when finished.";
+    readonly name: "connect_data_connection";
+    readonly description: "Connect or reconnect a data connection that is not currently active. Use this when a query fails because the connection is not active, or when you need to establish a connection before running queries.";
     readonly input_schema: {
         readonly type: "object";
         readonly properties: {
-            readonly message: {
+            readonly connection: {
                 readonly type: "string";
-                readonly description: "A brief summary of what was accomplished or a response to the user.";
+                readonly description: "The name of the data connection to connect";
             };
         };
-        readonly required: readonly ["message"];
+        readonly required: readonly ["connection"];
     };
 } | {
     name: string;

package/dist/llm/data/prompts.d.ts

@@ -1,6 +1,6 @@
 import { ModelConceptInput } from './models';
 export declare function filterDatePartConcepts(concepts: ModelConceptInput[]): ModelConceptInput[];
-export declare const leadIn = "You are a world-class assistant for generating queries in Trilogy, a SQL inspired language with similar syntax, Use the the syntax description below and field information to answer the user request. Return your answer with a short reasoning and a valid Trilogy query in triple double quotes.\n\n# Trilogy Syntax\n\nTrilogy statements define a semantic model or a query; collections of statements\nare written as `.preql` files. A statement returns data (SELECT) or defines\nconcepts (key | property | auto | metric), datasources, or parameters.\n\nimport <model> as <alias>; makes a model's fields available. <model> is a DOT-SEPARATED MODULE PATH relative to the project root (where trilogy.toml lives), never a file path: the file `raw/store_sales.preql` is imported as `import raw.store_sales as ss;` \u2014 replace each `/` with `.`, drop the `.preql`, keep the folder segment. When an imported model imports others (a fact with imported dimensions), those are dot paths: `enroll.student.name`. Typical usage imports ONE fact and reaches dimensions through it; nested dimensions carry ALL values (order.customers includes customers without orders).\n\nkey | property | auto | metric; define new concepts. `auto x <- ...` is a DEFINITION, not a precomputed value: each reference expands and re-evaluates in the consuming query's scope.\n\nparameter NAME TYPE [default <literal>]; \u2014 a runtime value supplied via `--param NAME=VALUE` (repeatable); append `?` to the type to allow null.\n\n## Combining models\n\n| Goal | Use |\n|---|---|\n| Typical query | no merge, no join: access all fields through dot-paths |\n| Blend two models on shared keys inside one query | scoped `subset\\|union\\|equal join` |\n| Make a connection universal to a whole file | `merge` |\n| Stack subsets/channels as rows | `union(...)` |\n| Rows in A but never in B (set difference) | `except(...)` |\n| Rows present in every source (set intersection) | `intersect(...)` |\n\n### Query-scoped join\n\nA typical fact already has its dimensions merged in, so no join is needed. Blending fact models or rowset outputs takes a scoped join, placed right after the select list, which DECLARES how the key domains relate: `subset join a = b` (a's values are contained in b's, a \u2286 b; b authoritative for the key), `union join a = b` (neither contains the other; the key is the coalesce of both sides and unmatched rows from BOTH sides are kept) or `equal join a = b` (ONE domain: a is an alias of b, every value on either side is on the other; the join renders inner).\n\nTwo rules decide whether the numbers are right, so apply them before reaching for the example:\n\n- Joins NEVER drop a row and NULL keys match null-safely; there is NO inner join. An intersection is an explicit `where <optional-side attr> is not null`.\n- JOIN ON THE FULL GRAIN: `explore` prints each fact's grain as @<k1, k2>; write one clause PER key. Matching only one key of a multi-key grain causes duplication.\n\nChaining, expression keys, union/subset mixing, multi-key and self-pair shapes: trilogy agent-info syntax example scoped-join.\n\nmerge <a> into ~<b>; is the persistent (whole-file) equivalent of `subset join a = b`; plain `merge a into b;` is the persistent equivalent of `equal join a = b`. Standalone statements; prefer a scoped join unless the connection is universal.\n\n### union / except / intersect (row set operations)\n\n`union(...)` row-stacks self-contained select arms positionally (SQL UNION ALL) into one named rowset (`with combined as union((armA), (armB), ...) -> (out1, out2, ...)`); `except(...)` / `intersect(...)` share that arm shape but are SQL SET operators (DISTINCT rows, null-safe whole-row compare, and except subtracts later arms from the FIRST, so arm order matters). Prefer except over a multi-column `not in` for \"in A but never in B\". Each arm dedups to its own output grain BEFORE stacking, so aggregate INSIDE each arm or the total silently undersums. Examples: trilogy agent-info syntax example union-stack-channels / except-intersect-setops.\n\n## Query structure\n\nTop-level statements first (each `;`-terminated), then a query with clauses in this EXACT order \u2014 all optional except select:\n\n```\n<top-level statements>;            # import / key / auto / rowset / merge / def / parameter\nwith <name> as                     # optional: name the select as a reusable rowset (CTE)\nwhere   <row condition>            # 1. filters INPUT rows, BEFORE aggregation\nselect  <col>, <agg> as name,      # 2. projection \u2014 grouping is AUTOMATIC by the\n                                   #    non-aggregated columns; never write GROUP BY\n  subset|union|equal join a = b (= c)?   # 3. blend models; one clause per key, right after the select list\nby rollup|cube|grouping sets (...) # 4. optional multi-level grouping for the whole select\nhaving  <result condition>         # 5. filters aggregated/joined RESULTS\norder by <col> asc|desc            # 6. sort\nlimit   <n>;                       # 7. cap rows\n```\n\nA rowset (`with <name> as where ... select ...;`) is a standalone statement, evaluated in isolation \u2014 it does NOT respond to the consuming query's context. All its outputs are namespaced: output `abc.def` of rowset `foo` is referenced as `foo.abc.def`. Pairing an output with a concept outside the rowset REQUIRES a declared join on the rowset's key (`subset join foo.key = key`); without one the query is disconnected. Alternatively project the concept inside the rowset and filter or select it through the handle (`where foo.cat = 'a'`). Alias every reused expression with `as`.\n\nFull annotated example: trilogy agent-info syntax example query-structure.\n\n### Not SQL \u2014 what to never write\n\n- **No FROM, GROUP BY, DISTINCT, SELECT \\*, or SQL-style set operators between selects.** Stack rows with `union(...)`; set difference/intersection with `except(...)`/`intersect(...)`; blend fact models with a scoped join.\n- **Grouping is automatic** by the non-aggregated fields in the SELECT \u2014 never write GROUP BY. Aggregates inherit the select's grain wherever they appear (where/select/having). Override per-aggregate with `agg(x) by <dims>`; `by *` aggregates across all data (single row). To weight a related dimension property once per fact row, project it to the fact grain first: `auto row_birth_year <- group(enroll.student.birth_year) by enroll.student_id, enroll.course_id;` then aggregate that.\n- **Output rows are deduplicated to the select grain.** To preserve legitimate duplicates (one row per matching fact), include the fact's grain keys in the select \u2014 hidden with the PREFIX `--` if they shouldn't appear in the output.\n- **Never write `distinct`.** `count(<key>)` is already distinct because keys are unique; `count_distinct(<property>)` counts distinct values of a non-key property.\n- **Count a COMPOSITE grain with `grain(...)`.** `count(grain(order_id, item.id))` counts order+item combinations; `grain(...)` is NEVER NULL. Never count one column of a multi-key grain \u2014 a coarser key counts its own distinct values and undercounts. `count_distinct(a, b)` is accepted as sugar for `count(grain(a, b))` (distinct combinations, NULL members included).\n- **An aggregate over a group with no qualifying rows is NULL, never 0.** `sum(x ? cond) by k` yields NULL for groups where nothing matches, so `= 0` matches nothing. Test emptiness with `count(key ? cond) by k = 0` or wrap: `coalesce(sum(x ? cond), 0)`.\n- **`count(1)` is invalid** \u2014 a constant does not identify rows. Use the row key, `count(grain(...))`, or `sum(1) by <grain>`.\n- **One-column expression subqueries only.** `(select ...)` is allowed where a scalar or membership set is expected (exactly one projected column; a scalar must also be one row: an aggregate with no `by`, or `limit 1`) \u2014 never as a SQL-style FROM-subquery. For related-entity filters prefer the dot-path: `where enrollments.student.state = 'TN'`, not a subselect.\n- **`--` is a HIDDEN-field prefix, not a comment** (it still changes query structure). Comments use `#` only.\n- **Aliases**: always use the full dot-path (`enroll.student.id`); alias every new expression with `as`; a select alias is usable in `having`/`order by` but NOT inside other select expressions or `where`, and must not rename a field back to an existing concept name.\n\n## Filtering\n\n`where` filters input rows before aggregation; `having` filters results after aggregation/windows. The inline filter `x ? cond` filters the immediate prior expression: `sum(credits ? enrolled = true)`.\n\nAggregates/windows in WHERE do not filter each other's inputs. Use inline filters, or a staged `then where` chain: each `then where` stage's aggregates compute over only the rows passing earlier stages (`where x = 5 then where sum(y) > 10` \u2261 `where x = 5 and sum(y ? x = 5) > 10`). One rule: the SAME cross-row expression cannot gate two different stages \u2014 give one an inline filter.\n\nWindows need all rows in their range: filter AFTER the window (in `having`) rather than in `where` when the window must see the full set.\n\n## Membership (semijoins)\n\n`in` / `not in` cross models without any declared relationship \u2014 the semijoin IS a scoped intersection. The right side is a concept or expression (never a subselect); build computed sets with an inline filter: `auto big_zip <- student.zip ? (count(student.id ? student.honors = true) by student.zip) > 10; ... where school.zip in big_zip`.\n\nMembership is IDENTITY matching, not SQL three-valued logic: NULL matches NULL; the result is always TRUE or FALSE (safe as a projected flag); `not in` is the exact complement (a NULL in the set never empties the result). For strict SQL behavior, add `x is not null`.\n\nA fact model contains ALL dimensional members, so `where students.id not in enroll.student_id` is typically a tautology \u2014 use `where enroll.id is null` instead. Tuple membership `(a, b) in (m.a, m.b)` requires both right-side concepts to resolve to ONE source (model or rowset); to test against a cross-model pair, stage it through a rowset first. Examples: existence-anti-join, staged-membership.\n\n## Aggregation\n\nAn aggregate without an explicit `by` is RESPONSIVE \u2014 its grain is set where it is consumed, not where it is declared (`auto avg_credits <- avg(enroll.credits);` becomes per-department when selected with `enroll.department`). Pin a grain inline: `sum(metric) by dim1, dim2 as name`; `by` accepts bare identifiers or parenthesized expressions: `avg(price) by (substring(phone, 1, 2))`.\n\nMulti-level grouping (`by rollup|cube|grouping sets (...)`) is a clause of the WHOLE select, placed before `having`: it computes every no-explicit-grain aggregate at every level in one pass (`by rollup (d1, d2)` \u2192 leaf, per-d1 subtotal, grand total). `grouping(<field>)` = 1 on rolled-up rows \u2014 use it to label levels rather than testing for NULL. Full detail: trilogy agent-info syntax example rollup.\n\n## Window functions\n\nDefault to windows for self-referential queries (period-over-period, running totals, rank, share of group). SQL-style syntax: `rank(<key>) over (partition by <g> order by <expr> desc)` (`dense_rank`/`row_number` same shape; multi-key `rank(a, b)`); `sum(x) over (partition by g order by t)` for running totals; `lag(<field>, <offset>) over (...)` / `lead(...)` for offsets (default 1). `partition by` is optional and accepts expressions.\n\n## Data types\n\nScalars: `string`, `bytes`, `bool`, `int`, `bigint`, `float`, `double`, `number`, `numeric(p,s)` (alias `decimal`; use for exact money), `date`, `datetime`, `timestamp`, `geography`, `any`. Composites: `array<T>`, `map<K, V>`, `struct<name: T, ...>`, `enum<T>[v1, v2, ...]`. Cast with `::type` or `cast(x as type)`: `\"2020-01-01\"::date`.\n\n`?` after a type marks it nullable (`property user.middle_name string?;`). `~` prefixing a concept marks the reference as a PARTIAL subset of the concept's domain \u2014 on a select item (`~customer.id`) or in `merge a into ~b` (a \u2286 b); it tells the planner this side is not authoritative.\n\n## Expression gotchas\n\n- `x ? cond` binds to a primary \u2014 wrap arithmetic: `(a - b) ? cond`, NOT `a - b ? cond`.\n- `a || b` is NULL if either side is NULL; `concat(...)` skips NULL arguments; `concat_ws(sep, ...)` joins with sep, skipping NULLs.\n- Date parts are unquoted: `date_part(d, year)`, never `'year'`; prefer `year(d)`. `date_diff(start, end, unit)` = end \u2212 start (a shipping lag is `date_diff(sold_date, ship_date, day)`).\n- Zero-argument functions still take parentheses: `current_date()`.\n- Factor repeated calculations into a `def` macro (invoked `@name(...)`) or reusable `auto` concepts.\n\n\nFunctions (the `aggregate` family doubles as the Aggregate Functions list):\naggregate: count|count_distinct|sum|max|min|avg|stddev|variance|array_agg|bool_or|bool_and|any|grouping(<arg1>) ; grouping_id(<arg1>, <arg2>, ..., <argN>)\nstring: concat|concat_strict|concat_ws(<arg1>, <arg2>, ..., <argN>) ; split|strpos|contains|trim|regexp_contains|format_time|parse_time(<arg1>, <arg2>) ; len|lower|upper|ltrim|rtrim|hex(<arg1>) ; substring|replace|regexp_extract|regexp_replace(<arg1>, <arg2>, <arg3>)\ndate/time: date|datetime|timestamp|second|minute|hour|day|day_of_week|week|month|quarter|year|month_name|day_name|unix_to_timestamp(<arg1>) ; date_spine(<arg1>, <arg2>) ; current_date|current_datetime()\n  date_part(<arg1>, <arg2>) e.g. date_part('2020-01-01'::date, year)\n  date_truncate(<arg1>, <arg2>) e.g. date_trunc('2020-01-01'::date, month)\n  date_add(<arg1>, <arg2>, <arg3>) e.g. date_add('2020-01-01'::date, month, 1)\n  date_sub(<arg1>, <arg2>, <arg3>) e.g. date_sub('2020-01-01'::date, day, 1)\n  date_diff(<arg1>, <arg2>, <arg3>) e.g. date_diff('2020-01-01'::date, '2020-01-02'::date, day)\n  current_timestamp() e.g. now()\narray/map/struct: unnest|array_distinct|array_sum|map_keys|map_values(<arg1>) ; struct|array(<arg1>, <arg2>, ..., <argN>) ; array_sort|array_to_string(<arg1>, <arg2>) ; array_transform|array_filter|generate_array(<arg1>, <arg2>, <arg3>)\nmath: mod|round|log|power|hash(<arg1>, <arg2>) ; abs|sqrt|random|floor|ceil(<arg1>)\nconditional/cast: case|simple_case|coalesce|greatest|least(<arg1>, <arg2>, ..., <argN>) ; cast|nullif(<arg1>, <arg2>) ; isnull(<arg1>)\ngeo: geo_from_text|geo_x|geo_y|geo_centroid(<arg1>) ; geo_point|geo_distance(<arg1>, <arg2>) ; geo_transform(<arg1>, <arg2>, <arg3>)\nother: is_not_distinct(<arg1>, <arg2>) ; prior(<arg1>) ; grain_pin(<arg1>, <arg2>, ..., <argN>)\n\nSome types carry trait metadata that adds meaning: 'latitude', 'longitude' and 'currency' are all 'float' with extra semantics.\n\nAdditional syntax examples:\nThese less-common patterns have complete, copy-pasteable examples. Do NOT guess\nthe syntax \u2014 print the full example on demand with\n`trilogy agent-info syntax example <name>`:\n- `python-datasource` - run a local Python script as a datasource: wrap a function in `trilogy.io.run`, which writes the Arrow IPC stream to stdout for you from a table, dataframe, or list of dicts; declare concepts, map script columns in `datasource (...)`, use `grain (...) file `path.py`;`, then reference locally declared concepts WITHOUT the datasource name as a prefix\n- `query-structure` - the exact clause order of a query, and how to define a rowset\n- `chart` - drawing a result rather than tabulating it: `chart layer <type> ( <role> <- <expr> as <name>, ... )` is a STATEMENT that wraps its own query - the bindings ARE the select; layers, roles, scales, reference lines and `from <select>`\n- `filtered-aggregate` - aggregating only the rows matching a condition, and counting rows correctly\n- `row-level-where-vs-having` - choosing between WHERE and HAVING for a threshold condition\n- `nested-aggregate-group-average` - the \"above 1.2x the group norm\" ask: inner `sum(x) by entity, group`, outer `avg(inner) by group`; use WHERE for the comparison when a separate output-only filter must not narrow the benchmark\n- `pivot-columns` - turn distinct values of a dimension into columns with a reusable `def` macro + filtered aggregate\n- `case-when` - `case when <cond> then <val> ... else <val> end` to relabel codes or bucket a measure into a derived value, then group by it\n- `window-period-over-period` - `lead`/`lag` over (order by ...) to compare a row to an offset period; build a scoped set with `<col> ? <cond>` and filter with `in`\n- `union-stack-channels` - stacking several sources/channels together as rows\n- `except-intersect-setops` - set difference or co-occurrence across sources\n- `scoped-join` - blending a second fact model or rowset into one query\n- `existence-anti-join` - keeping or excluding rows by whether a key matches another model\n- `set-intersect-difference` - count tuples present in / absent from other groups via per-group presence flags - the multi-column INTERSECT/EXCEPT idiom\n- `dedup-before-aggregate` - a `rowset <- select <cols>` collapses identical tuples to one row (SELECT-grain group by) before a downstream sum - the `distinct`/UNION substitute\n- `rollup` - subtotals and a grand total in one pass, and labeling the levels\n- `rank-over-rollup` - rank rollup subtotals/leaves with a SINGLE `rank(a,b) over (partition by level, parent ...)` - not separate ranks per level\n- `staged-membership` - filtering a fine-grain query by a set computed at a coarser grain\n- `correlated-exists-via-grouped-counts` - translate `EXISTS other` / `NOT EXISTS other matching` over the same model into two `count(...) by <grain>` compared in `where` (`> 1` = another exists, `= 1` = no other matches) - pin the correlation grain with `by`\n\nFor any response to the user, use this format -> put your actual response within triple double quotes with thinking and justification before it, in this format (replace placeholders with relevant content): Reasoning: {{reasoning}} \"\"\"{{ response }}\"\"\"\n";
+export declare const leadIn = "You are a world-class assistant for generating queries in Trilogy, a SQL inspired language with similar syntax, Use the the syntax description below and field information to answer the user request. Return your answer with a short reasoning and a valid Trilogy query in triple double quotes.\n\n# Trilogy Syntax\n\nTrilogy statements define a semantic model or a query; collections of statements\nare written as `.preql` files. A statement returns data (SELECT) or defines\nconcepts (key | property | auto | metric), datasources, or parameters.\n\nimport <model> as <alias>; makes a model's fields available. <model> is a DOT-SEPARATED MODULE PATH relative to the project root (where trilogy.toml lives), never a file path: the file `raw/store_sales.preql` is imported as `import raw.store_sales as ss;` \u2014 replace each `/` with `.`, drop the `.preql`, keep the folder segment. When an imported model imports others (a fact with imported dimensions), those are dot paths: `enroll.student.name`. Typical usage imports ONE fact and reaches dimensions through it; nested dimensions carry ALL values (order.customers includes customers without orders).\n\nkey | property | auto | metric; define new concepts. `auto x <- ...` is a DEFINITION, not a precomputed value: each reference expands and re-evaluates in the consuming query's scope.\n\nparameter NAME TYPE [default <literal>]; \u2014 a runtime value supplied via `--param NAME=VALUE` (repeatable); append `?` to the type to allow null.\n\n## Combining models\n\n| Goal | Use |\n|---|---|\n| Typical query | no merge, no join: access all fields through dot-paths |\n| Blend two models on shared keys inside one query | scoped `subset\\|union\\|equal join` |\n| Make a connection universal to a whole file | `merge` |\n| Stack subsets/channels as rows | `union(...)` |\n| Rows in A but never in B (set difference) | `except(...)` |\n| Rows present in every source (set intersection) | `intersect(...)` |\n\n### Query-scoped join\n\nA typical fact already has its dimensions merged in, so no join is needed. Blending fact models or rowset outputs takes a scoped join, placed right after the select list, which DECLARES how the key domains relate: `subset join a = b` (a's values are contained in b's, a \u2286 b; b authoritative for the key), `union join a = b` (neither contains the other; the key is the coalesce of both sides and unmatched rows from BOTH sides are kept) or `equal join a = b` (ONE domain: a is an alias of b, every value on either side is on the other; the join renders inner).\n\nTwo rules decide whether the numbers are right, so apply them before reaching for the example:\n\n- Joins NEVER drop a row and NULL keys match null-safely; there is NO inner join. An intersection is an explicit `where <optional-side attr> is not null`.\n- JOIN ON THE FULL GRAIN: `explore` prints each fact's grain as @<k1, k2>; write one clause PER key. Matching only one key of a multi-key grain causes duplication.\n\nChaining, expression keys, union/subset mixing, multi-key and self-pair shapes: trilogy agent-info syntax example scoped-join.\n\n`merge subset a = b;`, `merge union a = b;` and `merge equal a = b;` are the persistent (whole-file) equivalents of the three scoped joins; `merge a into ~b;` and `merge a into b;` are older spellings of `merge subset` and `merge equal`. Standalone statements; prefer a scoped join unless the connection is universal. Use `merge union` when each side has keys the other lacks (orphaned parents, dimension rows with no facts): `merge a into b` declares one domain and drops the unmatched rows.\n\n### union / except / intersect (row set operations)\n\n`union(...)` row-stacks self-contained select arms positionally (SQL UNION ALL) into one named rowset (`with combined as union((armA), (armB), ...) -> (out1, out2, ...)`); `except(...)` / `intersect(...)` share that arm shape but are SQL SET operators (DISTINCT rows, null-safe whole-row compare, and except subtracts later arms from the FIRST, so arm order matters). Prefer except over a multi-column `not in` for \"in A but never in B\". Each arm dedups to its own output grain BEFORE stacking, so aggregate INSIDE each arm or the total silently undersums. Examples: trilogy agent-info syntax example union-stack-channels / except-intersect-setops.\n\n## Query structure\n\nTop-level statements first (each `;`-terminated), then a query with clauses in this EXACT order \u2014 all optional except select:\n\n```\n<top-level statements>;            # import / key / auto / rowset / merge / def / parameter\nwith <name> as                     # optional: name the select as a reusable rowset (CTE)\nwhere   <row condition>            # 1. filters INPUT rows, BEFORE aggregation\nselect  <col>, <agg> as name,      # 2. projection \u2014 grouping is AUTOMATIC by the\n                                   #    non-aggregated columns; never write GROUP BY\n  subset|union|equal join a = b (= c)?   # 3. blend models; one clause per key, right after the select list\nby rollup|cube|grouping sets (...) # 4. optional multi-level grouping for the whole select\nhaving  <result condition>         # 5. filters aggregated/joined RESULTS\norder by <col> asc|desc            # 6. sort\nlimit   <n>;                       # 7. cap rows\n```\n\nA rowset (`with <name> as where ... select ...;`) is a standalone statement, evaluated in isolation \u2014 it does NOT respond to the consuming query's context. All its outputs are namespaced: output `abc.def` of rowset `foo` is referenced as `foo.abc.def`. Pairing an output with a concept outside the rowset REQUIRES a declared join on the rowset's key (`subset join foo.key = key`); without one the query is disconnected. Alternatively project the concept inside the rowset and filter or select it through the handle (`where foo.cat = 'a'`). Alias every reused expression with `as`.\n\nFull annotated example: trilogy agent-info syntax example query-structure.\n\n### Not SQL \u2014 what to never write\n\n- **No FROM, GROUP BY, DISTINCT, SELECT \\*, or SQL-style set operators between selects.** Stack rows with `union(...)`; set difference/intersection with `except(...)`/`intersect(...)`; blend fact models with a scoped join.\n- **Grouping is automatic** by the non-aggregated fields in the SELECT \u2014 never write GROUP BY. Aggregates inherit the select's grain wherever they appear (where/select/having). Override per-aggregate with `agg(x) by <dims>`; `by *` aggregates across all data (single row). To weight a related dimension property once per fact row, project it to the fact grain first: `auto row_birth_year <- group(enroll.student.birth_year) by enroll.student_id, enroll.course_id;` then aggregate that.\n- **Output rows are deduplicated to the select grain.** To preserve legitimate duplicates (one row per matching fact), include the fact's grain keys in the select \u2014 hidden with the PREFIX `--` if they shouldn't appear in the output.\n- **No `select distinct`.** `count(<key>)` is already distinct because keys are unique; `count(distinct(<property>))` counts distinct values of a non-key property. `distinct(x)` is `group(x) by x`: the distinct values of x, usable anywhere.\n- **Count a COMPOSITE grain with `grain(...)`.** `count(grain(order_id, item.id))` counts order+item combinations; `grain(...)` is NEVER NULL. Never count one column of a multi-key grain \u2014 a coarser key counts its own distinct values and undercounts.\n- **An aggregate over a group with no qualifying rows is NULL, never 0.** `sum(x ? cond) by k` yields NULL for groups where nothing matches, so `= 0` matches nothing. Test emptiness with `count(key ? cond) by k = 0` or wrap: `coalesce(sum(x ? cond), 0)`.\n- **A WHERE that leaves no rows returns no rows** - a grand total included: `where x > 100 select sum(x)` with nothing over 100 returns zero rows, not one NULL (or 0) row. The `?` filter is different: it narrows one aggregate's input, so the row still exists (`select count(k ? x > 100)` -> 0).\n- **Constants never count rows.** Aggregates resolve at the select grain, and a constant is one value per output row: `sum(1)` is 1 per group (`select state, sum(1)` -> 1 per state; `where ... select sum(1)` -> 1), and `count(1)` is rejected. To count rows, count a key (`count(ss.ticket_number)`), a composite row identity (`count(grain(a, b))`), or a filtered key (`count(k ? cond)`).\n- **One-column expression subqueries only.** `(select ...)` is allowed where a scalar or membership set is expected (exactly one projected column; a scalar must also be one row: an aggregate with no `by`, or `limit 1`) \u2014 never as a SQL-style FROM-subquery. For related-entity filters prefer the dot-path: `where enrollments.student.state = 'TN'`, not a subselect.\n- **`--` is a HIDDEN-field prefix, not a comment** (it still changes query structure). Comments use `#` only.\n- **Aliases**: always use the full dot-path (`enroll.student.id`); alias every new expression with `as`; a select alias is usable in `having`/`order by` but NOT inside other select expressions or `where`, and must not rename a field back to an existing concept name.\n\n## Filtering\n\n`where` filters input rows before aggregation; `having` filters results after aggregation/windows. The inline filter `x ? cond` filters the immediate prior expression: `sum(credits ? enrolled = true)`.\n\nAggregates/windows in WHERE do not filter each other's inputs. Use inline filters, or a staged `then where` chain: each `then where` stage's aggregates compute over only the rows passing earlier stages (`where x = 5 then where sum(y) > 10` \u2261 `where x = 5 and sum(y ? x = 5) > 10`). One rule: the SAME cross-row expression cannot gate two different stages \u2014 give one an inline filter.\n\nWindows need all rows in their range: filter AFTER the window (in `having`) rather than in `where` when the window must see the full set.\n\n## Membership (semijoins)\n\n`in` / `not in` cross models without any declared relationship \u2014 the semijoin IS a scoped intersection. The right side is a concept or expression (never a subselect); build computed sets with an inline filter: `auto big_zip <- student.zip ? (count(student.id ? student.honors = true) by student.zip) > 10; ... where school.zip in big_zip`.\n\nMembership is IDENTITY matching, not SQL three-valued logic: NULL matches NULL; the result is always TRUE or FALSE (safe as a projected flag); `not in` is the exact complement (a NULL in the set never empties the result). For strict SQL behavior, add `x is not null`.\n\nA fact model contains ALL dimensional members, so `where students.id not in enroll.student_id` is typically a tautology \u2014 use `where enroll.id is null` instead. Tuple membership `(a, b) in (m.a, m.b)` requires both right-side concepts to resolve to ONE source (model or rowset); to test against a cross-model pair, stage it through a rowset first. Examples: existence-anti-join, staged-membership.\n\n## Aggregation\n\nAn aggregate without an explicit `by` is RESPONSIVE \u2014 its grain is set where it is consumed, not where it is declared (`auto avg_credits <- avg(enroll.credits);` becomes per-department when selected with `enroll.department`). Pin a grain inline: `sum(metric) by dim1, dim2 as name`; `by` accepts bare identifiers or parenthesized expressions: `avg(price) by (substring(phone, 1, 2))`.\n\nMulti-level grouping (`by rollup|cube|grouping sets (...)`) is a clause of the WHOLE select, placed before `having`: it computes every no-explicit-grain aggregate at every level in one pass (`by rollup (d1, d2)` \u2192 leaf, per-d1 subtotal, grand total). `grouping(<field>)` = 1 on rolled-up rows \u2014 use it to label levels rather than testing for NULL. Full detail: trilogy agent-info syntax example rollup.\n\n## Window functions\n\nDefault to windows for self-referential queries (period-over-period, running totals, rank, share of group). SQL-style syntax: `rank(<key>) over (partition by <g> order by <expr> desc)` (`dense_rank`/`row_number` same shape; multi-key `rank(a, b)`); `sum(x) over (partition by g order by t)` for running totals; `lag(<field>, <offset>) over (...)` / `lead(...)` for offsets (default 1); these walk one row per key of the field (a property walks its key's rows), while `lag(distinct(<field>)) over (...)` walks the field's distinct values (`distinct(x)` = `group(x) by x`, usable anywhere). `partition by` is optional and accepts expressions.\n\n## Data types\n\nScalars: `string`, `bytes`, `bool`, `int`, `bigint`, `float`, `double`, `number`, `numeric(p,s)` (alias `decimal`; use for exact money), `date`, `datetime`, `timestamp`, `geography`, `any`. Composites: `array<T>`, `map<K, V>`, `struct<name: T, ...>`, `enum<T>[v1, v2, ...]`. Cast with `::type` or `cast(x as type)`: `\"2020-01-01\"::date`.\n\n`?` after a type marks it nullable (`property user.middle_name string?;`). `~` prefixing a concept marks the reference as a PARTIAL subset of the concept's domain \u2014 on a select item (`~customer.id`) or in `merge a into ~b` (a \u2286 b); it tells the planner this side is not authoritative.\n\n## Expression gotchas\n\n- `x ? cond` binds to a primary \u2014 wrap arithmetic: `(a - b) ? cond`, NOT `a - b ? cond`.\n- `a || b` is NULL if either side is NULL; `concat(...)` skips NULL arguments; `concat_ws(sep, ...)` joins with sep, skipping NULLs.\n- Date parts are unquoted: `date_part(d, year)`, never `'year'`; prefer `year(d)`. `date_diff(start, end, unit)` = end \u2212 start (a shipping lag is `date_diff(sold_date, ship_date, day)`).\n- Zero-argument functions still take parentheses: `current_date()`.\n- Factor repeated calculations into a `def` macro (invoked `@name(...)`) or reusable `auto` concepts.\n\n\nFunctions (the `aggregate` family doubles as the Aggregate Functions list):\naggregate: count|count_distinct|sum|max|min|avg|stddev|variance|array_agg|bool_or|bool_and|any|grouping(<arg1>) ; grouping_id(<arg1>, <arg2>, ..., <argN>)\nstring: concat|concat_strict|concat_ws(<arg1>, <arg2>, ..., <argN>) ; split|strpos|contains|trim|regexp_contains|format_time|parse_time(<arg1>, <arg2>) ; len|lower|upper|ltrim|rtrim|hex(<arg1>) ; substring|replace|regexp_extract|regexp_replace(<arg1>, <arg2>, <arg3>)\ndate/time: date|datetime|timestamp|second|minute|hour|day|day_of_week|week|month|quarter|year|month_name|day_name|unix_to_timestamp(<arg1>) ; date_spine(<arg1>, <arg2>) ; current_date|current_datetime()\n  date_part(<arg1>, <arg2>) e.g. date_part('2020-01-01'::date, year)\n  date_truncate(<arg1>, <arg2>) e.g. date_trunc('2020-01-01'::date, month)\n  date_add(<arg1>, <arg2>, <arg3>) e.g. date_add('2020-01-01'::date, month, 1)\n  date_sub(<arg1>, <arg2>, <arg3>) e.g. date_sub('2020-01-01'::date, day, 1)\n  date_diff(<arg1>, <arg2>, <arg3>) e.g. date_diff('2020-01-01'::date, '2020-01-02'::date, day)\n  current_timestamp() e.g. now()\narray/map/struct: unnest|array_distinct|array_sum|map_keys|map_values(<arg1>) ; struct|array(<arg1>, <arg2>, ..., <argN>) ; array_sort|array_to_string(<arg1>, <arg2>) ; array_transform|array_filter|generate_array(<arg1>, <arg2>, <arg3>)\nmath: mod|round|log|power|hash(<arg1>, <arg2>) ; abs|sqrt|random|floor|ceil(<arg1>)\nconditional/cast: case|simple_case|coalesce|greatest|least(<arg1>, <arg2>, ..., <argN>) ; cast|nullif(<arg1>, <arg2>) ; isnull(<arg1>)\ngeo: geo_from_text|geo_x|geo_y|geo_centroid(<arg1>) ; geo_point|geo_distance(<arg1>, <arg2>) ; geo_transform(<arg1>, <arg2>, <arg3>)\nother: is_not_distinct(<arg1>, <arg2>) ; prior(<arg1>) ; grain_pin(<arg1>, <arg2>, ..., <argN>)\n\nSome types carry trait metadata that adds meaning: 'latitude', 'longitude' and 'currency' are all 'float' with extra semantics.\n\nAdditional syntax examples:\nThese less-common patterns have complete, copy-pasteable examples. Do NOT guess\nthe syntax \u2014 print the full example on demand with\n`trilogy agent-info syntax example <name>`:\n- `python-datasource` - run a local Python script as a datasource: wrap a function in `trilogy.io.run`, which writes the Arrow IPC stream to stdout for you from a table, dataframe, or list of dicts; declare concepts, map script columns in `datasource (...)`, use `grain (...) file `path.py`;`, then reference locally declared concepts WITHOUT the datasource name as a prefix\n- `query-structure` - the exact clause order of a query, and how to define a rowset\n- `chart` - drawing a result rather than tabulating it: `chart layer <type> ( <role> <- <expr> as <name>, ... )` is a STATEMENT that wraps its own query - the bindings ARE the select; layers, roles, scales, reference lines and `from <select>`\n- `filtered-aggregate` - aggregating only the rows matching a condition, and counting rows correctly\n- `row-level-where-vs-having` - choosing between WHERE and HAVING for a threshold condition\n- `nested-aggregate-group-average` - the \"above 1.2x the group norm\" ask: inner `sum(x) by entity, group`, outer `avg(inner) by group`; use WHERE for the comparison when a separate output-only filter must not narrow the benchmark\n- `pivot-columns` - turn distinct values of a dimension into columns with a reusable `def` macro + filtered aggregate\n- `case-when` - `case when <cond> then <val> ... else <val> end` to relabel codes or bucket a measure into a derived value, then group by it\n- `window-period-over-period` - `lead`/`lag` over (order by ...) to compare a row to an offset period; build a scoped set with `<col> ? <cond>` and filter with `in`\n- `union-stack-channels` - stacking several sources/channels together as rows\n- `except-intersect-setops` - set difference or co-occurrence across sources\n- `scoped-join` - blending a second fact model or rowset into one query\n- `existence-anti-join` - keeping or excluding rows by whether a key matches another model\n- `set-intersect-difference` - count tuples present in / absent from other groups via per-group presence flags - the multi-column INTERSECT/EXCEPT idiom\n- `dedup-before-aggregate` - a `rowset <- select <cols>` collapses identical tuples to one row (SELECT-grain group by) before a downstream sum - the `distinct`/UNION substitute\n- `rollup` - subtotals and a grand total in one pass, and labeling the levels\n- `rank-over-rollup` - rank rollup subtotals/leaves with a SINGLE `rank(a,b) over (partition by level, parent ...)` - not separate ranks per level\n- `staged-membership` - filtering a fine-grain query by a set computed at a coarser grain\n- `correlated-exists-via-grouped-counts` - translate `EXISTS other` / `NOT EXISTS other matching` over the same model into two `count(...) by <grain>` compared in `where` (`> 1` = another exists, `= 1` = no other matches) - pin the correlation grain with `by`\n- `recursive-rollup` - walk a parent pointer (folder tree, org chart, process tree) to the top of each chain with `recurse_edge(key, parent)`, then aggregate per root\n\nFor any response to the user, use this format -> put your actual response within triple double quotes with thinking and justification before it, in this format (replace placeholders with relevant content): Reasoning: {{reasoning}} \"\"\"{{ response }}\"\"\"\n";
 export declare function conceptsToFieldPrompt(conceptInputs: ModelConceptInput[]): string;
 export declare function createPrompt(query: string, conceptInputs: ModelConceptInput[]): string;
 export declare function createFilterPrompt(query: string, conceptInputs: ModelConceptInput[]): string;

package/dist/llm/data/prompts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../llm/data/prompts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAIjD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,iBAAiB,EAAE,CAEzF;AAED,eAAO,MAAM,MAAM,mljBAKlB,CAAA;AAED,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,iBAAiB,EAAE,UAOvE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,UAG7E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,UAGnF;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,UAGtF"}
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../llm/data/prompts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAIjD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,iBAAiB,EAAE,CAEzF;AAED,eAAO,MAAM,MAAM,8rlBAKlB,CAAA;AAED,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,iBAAiB,EAAE,UAOvE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,UAG7E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,UAGnF;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,UAGtF"}