startx 0.9.4 → 0.9.9

package/packages/aix/src/tools/generic/summarizer.ts

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import { ITool } from "../i-tool.js";
+
+export const SummarizerTool: ITool[] = [
+	new ITool({
+		title: "query-summarizer",
+		description:
+			"Acts as a professional query architect. Evaluates the user's raw prompt for feasibility, summarizes the core intent, and outputs a highly optimized, dense step-by-step execution plan along with the specific tools required. If the request is unfeasible, ambiguous, or out of scope, it provides a clear abort reason.",
+		schema: z.object({
+			isFeasible: z
+				.boolean()
+				.describe("True if the query can be executed with available tools, false if it must be aborted."),
+			intentSummary: z.string().describe("A concise, professional summary of the user's core objective."),
+			executionPlan: z
+				.string()
+				.optional()
+				.describe(
+					"A dense, highly compressed step-by-step execution plan or raw database query. Omit all filler words."
+				),
+			requiredTools: z
+				.array(z.string())
+				.optional()
+				.describe("An array of specific tool names required to complete the execution plan."),
+			abortReason: z
+				.string()
+				.optional()
+				.describe("If isFeasible is false, provide a clear, actionable reason why the query cannot be executed."),
+		}),
+		run: ({ isFeasible, intentSummary, executionPlan, requiredTools, abortReason }) => {
+			try {
+				const payload = isFeasible
+					? { isFeasible, intentSummary, executionPlan, requiredTools }
+					: { isFeasible, intentSummary, abortReason };
+
+				return [
+					{
+						type: "text",
+						text: JSON.stringify(payload),
+					},
+					{
+						type: "resource_link",
+						uri: "return",
+						name: isFeasible ? "PlanGenerated" : "ExecutionAborted",
+						_meta: {
+							return: { isCompleted: true, isError: false },
+						},
+					},
+				];
+			} catch (err: unknown) {
+				return [
+					{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` },
+					{
+						type: "resource_link",
+						uri: "return",
+						name: "ToolFailure",
+						_meta: {
+							return: { isCompleted: true, isError: true },
+						},
+					},
+				];
+			}
+		},
+	}),
+	new ITool({
+		title: "general-summarizer",
+		description: "Summarizes a given query or text into a short and precise format.",
+		schema: z.object({
+			summary: z.string().describe("The short, precise summary of the input query."),
+		}),
+		run: ({ summary }) => {
+			try {
+				return [
+					{
+						type: "text",
+						text: JSON.stringify({ summary }),
+					},
+					{
+						type: "resource_link",
+						uri: "return",
+						name: "Summarized",
+						_meta: {
+							return: { isCompleted: true, isError: false },
+						},
+					},
+				];
+			} catch (err: unknown) {
+				return [
+					{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` },
+					{
+						type: "resource_link",
+						uri: "return",
+						name: "Failed",
+						_meta: {
+							return: { isCompleted: true, isError: true },
+						},
+					},
+				];
+			}
+		},
+	}),
+];

package/packages/aix/src/tools/i-tool.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import type { TInternal, ToolReturn } from "./types.js";
+
+type Awaitable<T> = T | PromiseLike<T>;
+
+export class ITool<S extends z.ZodObject = z.ZodObject> {
+	readonly title: string;
+	readonly description: string;
+	readonly schema: S;
+
+	private _run: (args: z.infer<S>, internal?: TInternal) => Awaitable<ToolReturn>;
+
+	public run = async (rawArgs: unknown, internal: TInternal): Promise<ToolReturn> => {
+		try {
+			const parsed = this.schema.parse(rawArgs);
+			return await this._run(parsed, internal);
+		} catch (err: unknown) {
+			const message = err instanceof Error ? err.message : typeof err === "string" ? err : JSON.stringify(err);
+			return [{ type: "text", text: message }];
+		}
+	};
+	constructor(def: {
+		title: string;
+		description: string;
+		schema: S;
+		run: (args: z.infer<S>, internal?: TInternal) => Awaitable<ToolReturn>;
+	}) {
+		this.title = def.title;
+		this.description = def.description;
+		this.schema = def.schema;
+		this._run = def.run;
+	}
+}

package/packages/aix/src/tools/index.ts

@@ -0,0 +1,2 @@
+export * from "./system/index.js";
+export * from "./generic/index.js";

package/packages/aix/src/tools/system/index.ts

@@ -0,0 +1,297 @@
+import * as vm from "node:vm";
+import { z } from "zod";
+import { ITool } from "../i-tool.js";
+
+export const SystemInternalTools: ITool[] = [
+	new ITool({
+		title: "end_response",
+		description: "Call this tool if you want to end the response to the user.",
+		schema: z.object({
+			note: z
+				.string()
+				.describe(
+					"Answer the user query with a note in professional way that has the task summary and the response of what user asked you can also use variable and perform js-operations on them. A valid variable format is {{message.VARIABLE_NAME}}."
+				),
+		}),
+		run: ({ note }: { note: string }) => {
+			try {
+				return [
+					{
+						type: "text",
+						text: `${note}`,
+					},
+					{
+						type: "resource_link",
+						uri: "return",
+						name: note,
+						_meta: {
+							return: {
+								isCompleted: true,
+								isError: false,
+							},
+						},
+					},
+				];
+			} catch (err: unknown) {
+				const message = err instanceof Error ? err.message : String(err);
+				return [{ type: "text", text: `Error fetching forecast: ${message}` }];
+			}
+		},
+	}),
+
+	new ITool({
+		title: "no_relevant_tool",
+		description:
+			"Call this tool if there is no relevant tool that can help you to complete this task. Please respond to user query in professional way.",
+		schema: z.object({
+			note: z.string().describe("Please respond to the user query."),
+		}),
+		run: ({ note }: { note: string }) => {
+			try {
+				return [
+					{
+						type: "text",
+						text: `${note}`,
+					},
+					{
+						type: "resource_link",
+						uri: "return",
+						name: note,
+						_meta: {
+							return: {
+								isCompleted: true,
+								isError: false,
+							},
+						},
+					},
+				];
+			} catch (err: unknown) {
+				const message = err instanceof Error ? err.message : String(err);
+				return [{ type: "text", text: `Error fetching forecast: ${message}` }];
+			}
+		},
+	}),
+
+	// new ITool({
+	// 	title: "continue_response",
+	// 	description:
+	// 		"Call this tool if some parts of job is done and there is next action to be taken make sure it doesn't involve user interaction.",
+	// 	schema: z.object({
+	// 		note: z.string().describe("Please provide a proper note of the next execution"),
+	// 	}),
+	// 	run: ({ note }: { note: string }) => {
+	// 		try {
+	// 			return [
+	// 				{
+	// 					type: "text",
+	// 					text: `${note}`,
+	// 				},
+	// 			];
+	// 		} catch (err: unknown) {
+	// 			const message = err instanceof Error ? err.message : String(err);
+	// 			return [{ type: "text", text: `Error fetching forecast: ${message}` }];
+	// 		}
+	// 	},
+	// }),
+
+	new ITool({
+		title: "error_response",
+		description: "Call this tool if the job is failed because of some errors.",
+		schema: z.object({
+			note: z.string().describe("Please provide a proper error with a note how to solve this error."),
+		}),
+		run: ({ note }: { note: string }) => {
+			try {
+				return [
+					{
+						type: "text",
+						text: `${note}`,
+					},
+					{
+						type: "resource_link",
+						uri: "return",
+						name: note,
+						_meta: {
+							return: {
+								isCompleted: true,
+								isError: true,
+							},
+						},
+					},
+				];
+			} catch (err: unknown) {
+				const message = err instanceof Error ? err.message : String(err);
+				return [{ type: "text", text: `Error fetching forecast: ${message}` }];
+			}
+		},
+	}),
+
+	new ITool({
+		title: "get_data_by_tool_id",
+		description: `
+        Write JavaScript logic using {{data}} as the dataset variable.
+        You can use top‑level statements (const, loops, etc.).
+        **You must include a return statement** in your operation.
+
+        When performing operation make everything **case insensitive** so that 10mg or 10 mg or 10Mg are all considered the same.
+        Always handle variable that has null or undefined values.
+        Example:
+          const filtered = {{data}}.filter(x => x.active);
+          return filtered.map(x => x.name);
+    `,
+		schema: z.object({
+			toolId: z.string().describe("ID of the structure data to fetch."),
+			operation: z.string().describe("JS function body using {{data}}. Must include return."),
+		}),
+		run: async ({ toolId, operation }, internal) => {
+			try {
+				const DATA_VAR = "DATA_PLACEHOLDER";
+				const data = internal?.toolData?.[toolId];
+
+				if (!data) {
+					throw new Error(`No data found for structureDataId: ${toolId}`);
+				}
+
+				const functionBody = operation.replaceAll("{{data}}", DATA_VAR);
+
+				const context = vm.createContext({
+					[DATA_VAR]: data,
+				});
+
+				const script = new vm.Script(`
+          (async () => {
+            ${functionBody}
+          })();
+        `);
+
+				const result = (await script.runInContext(context)) as unknown;
+
+				return [
+					{
+						type: "text",
+						text: `✅ Success: structureDataId \`${toolId}\`.`,
+					},
+					{ type: "text", text: JSON.stringify(result, null, 2) },
+				];
+			} catch (err: unknown) {
+				const message = err instanceof Error ? err.message : String(err);
+				return [{ type: "text", text: `❌ Error: ${message}` }];
+			}
+		},
+	}),
+	new ITool({
+		title: "execute_javascript",
+		description: `
+    Executes JavaScript code in a sandboxed VM. Use this tool for ANY JavaScript execution, including mathematical calculations, logical operations, data processing, and resolving variables provided in the user's prompt.
+
+    CRITICAL INSTRUCTIONS:
+    1. SYNTAX FOR VARIABLES: If referencing dataset variables from the prompt, you MUST use the exact format: {{vars.VARIABLE_NAME}}. Only use this syntax if a variable actually exists in the prompt.
+    2. RETURN STATEMENT: Your code is executed in an async IIFE and MUST include a top-level 'return' statement with the final result.
+    3. RESILIENCE: Always handle potential null, undefined, or edge cases gracefully.
+    4. COMPLETION FLAG ('isCompleted'):
+       - Set to TRUE if this execution fully resolves the user's query. If true, your script MUST return a cleanly formatted Markdown string ready to be shown to the user.
+       - Set to FALSE if you only need to extract/calculate intermediate data for your own further reasoning.
+
+    EXAMPLE 1 (Math):
+    return Math.sqrt(144) + 5;
+
+    EXAMPLE 2 (Variables):
+    const data = {{vars.MEDICATIONS}} || [];
+    const filtered = data.filter(item => item && item.dose && item.dose.toLowerCase().replace(' ', '') === '10mg');
+    return filtered.map(item => \`- \${item.name}\`).join('\\n');
+
+		Mark isCompleted as true if this operation fully resolves the user's request (script must return formatted Markdown).
+  `.trim(),
+		schema: z.object({
+			operation: z
+				.string()
+				.describe(
+					"Valid JavaScript code. MUST contain a 'return' statement. Do not include markdown code blocks (```javascript) in this string."
+				),
+			isCompleted: z
+				.boolean()
+				.describe(
+					"Set to true if this operation fully resolves the user's request (script must return formatted Markdown). Set to false if extracting intermediate data."
+				),
+		}),
+		run: async ({ isCompleted, operation }, internal) => {
+			try {
+				const contextObj: Record<string, unknown> = {};
+				let resolvedOp = operation;
+
+				resolvedOp = resolvedOp
+					.replace(/^```javascript\n/, "")
+					.replace(/^```js\n/, "")
+					.replace(/\n```$/, "");
+
+				for (const [key, value] of internal?.vars.entries() || []) {
+					const sanitized = key;
+
+					// Attempt to parse stringified JSON data before injecting into the VM
+					let contextValue = value.data;
+					if (typeof contextValue === "string") {
+						try {
+							contextValue = JSON.parse(contextValue);
+						} catch {
+							// Leave as string if not valid JSON
+						}
+					}
+
+					contextObj[sanitized] = contextValue;
+
+					const placeholder = new RegExp(`\\{\\{vars\\.${key}\\}\\}`, "g");
+					resolvedOp = resolvedOp.replace(placeholder, sanitized);
+				}
+
+				const context = vm.createContext(contextObj);
+
+				const script = new vm.Script(`
+        (async () => {
+          ${resolvedOp}
+        })();
+      `);
+
+				const result = (await script.runInContext(context)) as unknown;
+				const textResult = JSON.stringify(result)?.length > 3 ? result : "No data found";
+
+				if (isCompleted) {
+					return [
+						{
+							type: "text",
+							text: String(textResult),
+						},
+						{
+							type: "resource_link",
+							uri: "return",
+							name: "Execution completed",
+							_meta: {
+								return: {
+									isCompleted: true,
+									isError: false,
+								},
+							},
+						},
+					];
+				}
+
+				return [{ type: "text", text: JSON.stringify(textResult, null, 2) }];
+			} catch (err: unknown) {
+				const message = err instanceof Error ? err.message : String(err);
+				return [
+					{ type: "text", text: `❌ Error: ${message}` },
+					{
+						type: "resource_link",
+						uri: "return",
+						name: "Execution failed",
+						_meta: {
+							return: {
+								isCompleted: false,
+								isError: true,
+							},
+						},
+					},
+				];
+			}
+		},
+	}),
+];

package/packages/aix/src/tools/tool-manager.ts

@@ -0,0 +1,241 @@
+import { IEvent } from "@repo/lib/events";
+import { jsonrepair } from "jsonrepair";
+import type z from "zod";
+import type { GenericTool, TInternal, ToolConnector } from "./types.js";
+import type { AiEventType } from "../providers/ai-event.js";
+import type { AiChatMessage, AiResource } from "../providers/types.js";
+
+export class ToolManager {
+	public whitelist: string[] = [];
+	private events: IEvent<AiEventType>;
+	public registered: Map<string, GenericTool> = new Map();
+	public tools: Map<string, GenericTool> = new Map();
+
+	constructor(props?: { whitelist?: string[]; events?: IEvent<AiEventType> }) {
+		this.whitelist = props?.whitelist ?? [];
+		this.events = props?.events || new IEvent();
+	}
+
+	public async attachTools(props: ToolConnector) {
+		switch (props.type) {
+			case "internal": {
+				for (const t of props.tool) {
+					this.registered.set(t.title, {
+						name: t.title
+							.replace(/^[^a-zA-Z_]+/, "")
+							.replace(/[^a-zA-Z0-9_.-]/g, "_")
+							.slice(0, 64),
+						description: t.description,
+						schema: t.schema,
+						run: t.run,
+					});
+					if (!this.whitelist.includes(t.title)) {
+						this.events.emit("log", {
+							type: "warn",
+							message: `Tool ${t.title} is not whitelisted. Skipping...`,
+						});
+						continue;
+					}
+					if (this.tools.has(t.title)) {
+						this.events.emit("log", {
+							type: "warn",
+							message: `Tool ${t.title} is already registered. Skipping...`,
+						});
+						continue;
+					}
+					this.events.emit("log", {
+						type: "info",
+						message: `Registering tool ${t.title}`,
+					});
+					this.tools.set(t.title, {
+						name: t.title
+							.replace(/^[^a-zA-Z_]+/, "")
+							.replace(/[^a-zA-Z0-9_.-]/g, "_")
+							.slice(0, 64),
+						description: t.description,
+						schema: t.schema,
+						run: t.run,
+					});
+				}
+				break;
+			}
+
+			case "mcp": {
+				// TODO: implement mcp tool call
+				// Remove this
+				await new Promise(resolve => setTimeout(resolve, 0));
+				throw new Error("MCP tool call not implemented yet!");
+			}
+			default: {
+				throw new Error(`Unknown tool type: ${JSON.stringify(props)}`);
+			}
+		}
+	}
+	public getActiveTools() {
+		return Array.from(this.tools.values()).map(e => ({
+			name: e.name,
+			description: e.description,
+			input_schema: e.schema,
+		}));
+	}
+	public getRegisteredTools() {
+		return Array.from(this.registered.values()).map(e => ({
+			name: e.name,
+			description: e.description,
+			input_schema: e.schema,
+		}));
+	}
+	public removeTool(title: string) {
+		if (this.tools.has(title)) {
+			this.events.emit("log", {
+				type: "info",
+				message: `Unregistering tool ${title}`,
+			});
+			this.tools.delete(title);
+		}
+	}
+	public async callTool(props: {
+		name: string;
+		args: z.infer<GenericTool["schema"]>;
+		toolId: string;
+		internal?: TInternal;
+	}) {
+		try {
+			const tool = this.tools.get(props.name);
+			if (!tool) {
+				throw new Error(`Tool ${props.name} not found`);
+			}
+
+			this.events.emit("tool.start", {
+				name: tool.name,
+				args: props.args,
+			});
+			const result = await tool.run(
+				ToolManager.parseArgs(props.args) as z.infer<GenericTool["schema"]>,
+				props.internal
+			);
+			this.events.emit("tool.finish", result);
+
+			if (!result.length) {
+				throw new Error("Tool result not returned anything. Please try again.");
+			}
+			const content: AiChatMessage[] = [];
+			let isCompleted = false;
+			let isError = false;
+
+			const resources: AiResource[] = [];
+			for (const item of result) {
+				if (item.type === "text") {
+					content.push({
+						role: "tool",
+						content: item.text,
+						timestamp: new Date(),
+						tool_call_id: props.toolId,
+					});
+					continue;
+				}
+				if (item._meta.return) {
+					isCompleted = !!item._meta.return.isCompleted;
+					isError = !!item._meta.return.isError;
+				}
+				switch (item.uri) {
+					case "return": {
+						const returnMeta = item._meta.return;
+						if (returnMeta?.isCompleted) isCompleted = true;
+						if (returnMeta?.isError) isError = true;
+						break;
+					}
+					case "table": {
+						resources.push({
+							type: "table",
+							data: item._meta.data,
+							columns: item._meta.columns,
+						});
+						break;
+					}
+					case "image": {
+						resources.push({
+							type: "image",
+							source: item._meta.source,
+							alt: item._meta.alt,
+						});
+						break;
+					}
+					case "file": {
+						resources.push({
+							type: "file",
+							source: item._meta.source,
+						});
+						break;
+					}
+					case "user_message": {
+						content.push({
+							role: "user",
+							content: item._meta.message,
+							timestamp: new Date(),
+						});
+						break;
+					}
+				}
+			}
+			return {
+				isCompleted,
+				isError,
+				content,
+				resources,
+			};
+		} catch (error: unknown) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			const message = `Tool ${props.name} failed: ${err.message}`;
+			this.events.emit("log", {
+				type: "error",
+				message,
+				stack: err.stack,
+				meta: err.cause as Record<string, unknown>,
+			});
+			return {
+				isCompleted: false,
+				isError: true,
+				resources: [],
+				content: [
+					{
+						role: "tool",
+						content: message,
+					},
+				] as AiChatMessage[],
+			};
+		}
+	}
+	protected static parseArgs = (obj: any): any => {
+		if (typeof obj !== "object" || obj === null) return obj;
+
+		// Create a new object/array to avoid mutating the original payload
+		const parsedObj = Array.isArray(obj) ? [...obj] : { ...obj };
+
+		for (const key in parsedObj) {
+			const value = parsedObj[key];
+
+			if (typeof value === "string" && (value.trim().startsWith("[") || value.trim().startsWith("{"))) {
+				try {
+					// 1. Try a standard parse first
+					parsedObj[key] = JSON.parse(value);
+				} catch {
+					try {
+						// 2. If it fails (due to unescaped quotes, etc.), repair it and try again
+						parsedObj[key] = JSON.parse(jsonrepair(value));
+					} catch {
+						// 3. If it still fails, it's not JSON. Leave it as a string.
+					}
+				}
+
+				// Recursively parse the newly parsed object (in case of deep nesting)
+				if (typeof parsedObj[key] === "object") {
+					parsedObj[key] = this.parseArgs(parsedObj[key]);
+				}
+			} else if (typeof value === "object") {
+				parsedObj[key] = this.parseArgs(value);
+			}
+		}
+		return parsedObj;
+	};
+}