startx 0.9.2 → 0.9.8

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

@@ -0,0 +1,290 @@
+import * as vm from "node:vm";
+import pg from "pg";
+import { z } from "zod";
+import { ITool } from "../i-tool.js";
+
+/**
+ * Pool cache
+ */
+const poolCache: Map<string, pg.Pool> = new Map();
+
+function getPool(url: string) {
+	if (!poolCache.has(url)) {
+		poolCache.set(url, new pg.Pool({ connectionString: url }));
+	}
+	return poolCache.get(url)!;
+}
+
+export const DatabaseTools: ITool[] = [
+	/**
+	 * GET TABLE LIST (replaces get_database_list)
+	 */
+	new ITool({
+		title: "get_table_list",
+		description: "Returns list of tables from the connected Postgres database including schema and table name.",
+		schema: z.object({}),
+		run: async (_: {}, internal) => {
+			try {
+				const url = internal?.system?.DATABASE_URL as string | undefined;
+				if (!url) {
+					return [
+						{ type: "text", text: "Missing connection URL in internal." },
+						{
+							type: "resource_link",
+							uri: "return",
+							name: "Missing connection",
+							_meta: { return: { isCompleted: false, isError: true } },
+						},
+					];
+				}
+
+				const pool = getPool(url);
+
+				const result = (await pool.query(`
+					SELECT
+						table_schema,
+						table_name
+					FROM information_schema.tables
+					WHERE table_type = 'BASE TABLE'
+					AND table_schema NOT IN ('pg_catalog', 'information_schema')
+					ORDER BY table_schema, table_name;
+				`)) as { rows: Array<{ table_schema: string; table_name: string }> };
+
+				const tables = result.rows.map(row => ({
+					schema: row.table_schema,
+					table_name: row.table_name,
+				}));
+
+				if (!tables.length) {
+					return [
+						{ type: "text", text: "No tables found." },
+						{
+							type: "resource_link",
+							uri: "return",
+							name: "No tables",
+							_meta: { return: { isCompleted: true, isError: false } },
+						},
+					];
+				}
+
+				return [
+					{
+						type: "text",
+						text: JSON.stringify(tables, null, 2),
+					},
+				];
+			} catch (err: unknown) {
+				const message = err instanceof Error ? err.message : String(err);
+
+				return [
+					{ type: "text", text: `Failed to fetch tables: ${message}` },
+					{
+						type: "resource_link",
+						uri: "return",
+						name: "Table fetch error",
+						_meta: { return: { isCompleted: false, isError: true } },
+					},
+				];
+			}
+		},
+	}),
+
+	/**
+	 * EXECUTE SQL
+	 */
+	new ITool({
+		title: "execute_postgres_sql",
+		description: `
+    Execute SQL on the connected Postgres database using connectionUrl from internal.
+    Supports evaluating JavaScript expressions inside {{...}} blocks to dynamically inject values.
+    The variables are accessible via the 'vars' object and are safely parameterized to prevent SQL injection.
+
+    EXAMPLE 1 (Basic Variable):
+    SELECT * FROM users WHERE id = {{vars.USER_ID}};
+
+    EXAMPLE 2 (Math/Logic Operation):
+    SELECT * FROM orders WHERE amount > {{vars.MIN_AMOUNT * 1.5}} AND status = {{(vars.IS_ACTIVE ? 'ACTIVE' : 'INACTIVE')}};
+
+    EXAMPLE 3 (Array/String Manipulation):
+    SELECT * FROM products WHERE category = {{vars.CATEGORIES[0].toLowerCase()}};
+
+		Mark isCompleted as true if this operation fully resolves the user's request.
+    `.trim(),
+		schema: z.object({
+			sql: z
+				.string()
+				.describe(
+					"The SQL query. Use {{expression}} to evaluate JS and safely inject values via parameterized queries."
+				),
+			isCompleted: z
+				.boolean()
+				.describe(
+					"Set to true if this operation fully resolves the user's request (must return formatted Markdown). Set to false if you just need to extract data for your own further reasoning."
+				),
+		}),
+		run: async (props, internal) => {
+			try {
+				const url = internal?.system?.DATABASE_URL as string | undefined;
+
+				if (!url) {
+					return [
+						{ type: "text", text: "Missing connection URL." },
+						{
+							type: "resource_link",
+							uri: "return",
+							name: "Missing connection",
+							_meta: { return: { isCompleted: true, isError: true } },
+						},
+					];
+				}
+
+				const rawSql = String(props.sql || "").trim();
+
+				if (!rawSql) {
+					return [
+						{ type: "text", text: "Missing SQL query." },
+						{
+							type: "resource_link",
+							uri: "return",
+							name: "Missing SQL",
+							_meta: { return: { isCompleted: true, isError: true } },
+						},
+					];
+				}
+
+				const contextObj: Record<string, unknown> = {};
+				for (const [key, value] of internal?.vars?.entries() || []) {
+					let parsedData = value.data;
+					// Attempt to parse stringified JSON outputs back into objects
+					if (typeof parsedData === "string") {
+						try {
+							parsedData = JSON.parse(parsedData);
+						} catch (e) {
+							// If it's not valid JSON, leave it as a string
+						}
+					}
+					contextObj[key] = parsedData;
+				}
+
+				const context = vm.createContext({ vars: contextObj });
+
+				const values: any[] = [];
+				let paramIndex = 1;
+				let resolvedSql = rawSql;
+
+				try {
+					resolvedSql = rawSql.replace(/\{\{(.+?)\}\}/g, (_match, expression: string) => {
+						const script = new vm.Script(expression.trim());
+						const evaluatedValue = script.runInContext(context);
+
+						// Optional: Add safety check for undefined evaluations
+						if (evaluatedValue === undefined) {
+							throw new Error(`Expression '${expression}' evaluated to undefined.`);
+						}
+
+						values.push(evaluatedValue);
+						return `$${paramIndex++}`;
+					});
+				} catch (evalError: any) {
+					return [
+						{ type: "text", text: `Expression evaluation failed: ${evalError.message}` },
+						{
+							type: "resource_link",
+							uri: "return",
+							name: "Evaluation error",
+							_meta: { return: { isCompleted: false, isError: true } },
+						},
+					];
+				}
+
+				const firstWord = resolvedSql.match(/^\s*(\w+)/i)?.[1]?.toUpperCase() || "";
+				const destructiveWords = ["INSERT", "UPDATE", "DELETE", "CREATE", "DROP", "ALTER", "TRUNCATE"];
+				const isDestructive = destructiveWords.includes(firstWord);
+				const isAdmin = Boolean(internal?.system?.IS_ADMIN ?? true);
+
+				if (isDestructive && !isAdmin) {
+					return [
+						{
+							type: "text",
+							text: `Destructive query (${firstWord}) blocked. Not admin.`,
+						},
+						{
+							type: "resource_link",
+							uri: "return",
+							name: "Permission denied",
+							_meta: { return: { isCompleted: false, isError: true } },
+						},
+					];
+				}
+
+				const pool = getPool(url);
+				const result = await pool.query({ text: resolvedSql, values });
+				const rows = Array.isArray(result.rows) ? result.rows : [];
+
+				const columns = (result.fields || []).map((f: any) => ({
+					name: f.name,
+					dataTypeID: f.dataTypeID,
+				}));
+
+				if (props.isCompleted) {
+					return [
+						{
+							type: "text",
+							text: JSON.stringify(
+								{
+									rowCount: result.rowCount,
+									returnedRows: rows.length,
+									rows,
+									columns,
+								},
+								null,
+								2
+							),
+						},
+						{
+							type: "resource_link",
+							uri: "return",
+							name: "Execution completed",
+							_meta: {
+								return: {
+									isCompleted: true,
+									isError: false,
+								},
+							},
+						},
+					];
+				}
+
+				return [
+					{
+						type: "text",
+						text: JSON.stringify(
+							{
+								rowCount: result.rowCount,
+								returnedRows: rows.length,
+								rows,
+								columns,
+							},
+							null,
+							2
+						),
+					},
+				];
+			} catch (err: unknown) {
+				const message = err instanceof Error ? err.message : String(err);
+
+				return [
+					{ type: "text", text: `SQL execution failed: ${message}` },
+					{
+						type: "resource_link",
+						uri: "return",
+						name: "SQL error",
+						_meta: {
+							return: { isCompleted: false, isError: true },
+						},
+					},
+				];
+			}
+		},
+	}),
+];

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

@@ -0,0 +1,216 @@
+import axios from "axios";
+import { z } from "zod";
+import { ITool } from "../i-tool.js";
+import type { ToolReturn } from "../types.js";
+
+async function findCoordinates(location: string) {
+	const geoRes = await axios.get("https://geocoding-api.open-meteo.com/v1/search", {
+		params: { name: location, count: 1 },
+	});
+
+	const geoData = geoRes.data;
+	if (!geoData.results?.length) {
+		return null;
+	}
+
+	const { latitude, longitude } = geoData.results[0];
+	return { latitude, longitude };
+}
+
+export const WeatherTools: ITool[] = [
+	new ITool({
+		title: "get_forecast",
+		description: "Returns the 1-day weather forecast for a given location.",
+		schema: z.object({
+			location: z.string().describe("Location name, city, or place."),
+		}),
+		run: async props => {
+			try {
+				const coords = await findCoordinates(props.location);
+
+				if (!coords) {
+					return [
+						{
+							type: "text",
+							text: `Could not find location: ${props.location}`,
+						},
+						{
+							type: "resource_link",
+							uri: "return",
+							name: "Location not found",
+							_meta: {
+								return: {
+									isCompleted: false,
+									isError: true,
+								},
+							},
+						},
+					];
+				}
+
+				const weatherRes = await axios.get("https://api.open-meteo.com/v1/forecast", {
+					params: {
+						latitude: coords.latitude,
+						longitude: coords.longitude,
+						daily: "weathercode,temperature_2m_max,temperature_2m_min",
+						timezone: "auto",
+					},
+				});
+
+				const forecast = weatherRes.data.daily;
+
+				const text = `Forecast for ${props.location}:
+					- Max Temp: ${forecast.temperature_2m_max[0]}°C
+					- Min Temp: ${forecast.temperature_2m_min[0]}°C
+					- Weather Code: ${forecast.weathercode[0]}`;
+				const response: ToolReturn = [
+					{
+						type: "text",
+						text,
+					},
+				];
+
+				return response;
+			} catch (err: unknown) {
+				const message = err instanceof Error ? err.message : String(err);
+				return [
+					{ type: "text", text: `Error fetching forecast: ${message}` },
+					{
+						type: "resource_link",
+						uri: "return",
+						name: "Forecast error",
+						_meta: {
+							return: {
+								isCompleted: true,
+								isError: true,
+							},
+						},
+					},
+				];
+			}
+		},
+	}),
+
+	new ITool({
+		title: "current_temperature",
+		description: "Returns current temperature in Celsius.",
+		schema: z.object({
+			city: z.string().describe("City name."),
+		}),
+		run: async ({ city }) => {
+			try {
+				const coords = await findCoordinates(city);
+
+				if (!coords) {
+					return [
+						{
+							type: "text",
+							text: `Could not find city: ${city}`,
+						},
+						{
+							type: "resource_link",
+							uri: "return",
+							name: "City not found",
+							_meta: {
+								return: {
+									isCompleted: true,
+									isError: true,
+								},
+							},
+						},
+					];
+				}
+
+				const weatherRes = await axios.get("https://api.open-meteo.com/v1/forecast", {
+					params: {
+						latitude: coords.latitude,
+						longitude: coords.longitude,
+						current_weather: true,
+						timezone: "auto",
+					},
+				});
+
+				const temperature = weatherRes.data.current_weather?.temperature;
+
+				const text = `The current temperature in ${city} is ${temperature}°C.`;
+				const response: ToolReturn = [
+					{
+						type: "text",
+						text,
+					},
+				];
+
+				return response;
+			} catch (err: unknown) {
+				const message = err instanceof Error ? err.message : String(err);
+				return [
+					{ type: "text", text: `Error fetching temperature: ${message}` },
+					{
+						type: "resource_link",
+						uri: "return",
+						name: "Temperature error",
+						_meta: {
+							return: {
+								isCompleted: false,
+								isError: true,
+							},
+						},
+					},
+				];
+			}
+		},
+	}),
+
+	new ITool({
+		title: "convert_temperature",
+		description: "Converts a temperature between Celsius and Fahrenheit.",
+		schema: z.object({
+			value: z.number().describe("Temperature value."),
+			to: z.enum(["celsius", "fahrenheit"]).describe("Target unit."),
+		}),
+		run: ({ value, to }: { value: number; to: "celsius" | "fahrenheit" }) => {
+			try {
+				let result: string;
+
+				if (to === "celsius") {
+					const c = ((value - 32) * 5) / 9;
+					result = `${value}°F is ${c.toFixed(2)}°C`;
+				} else {
+					const f = (value * 9) / 5 + 32;
+					result = `${value}°C is ${f.toFixed(2)}°F`;
+				}
+
+				return [
+					{ type: "text", text: result },
+					{
+						type: "resource_link",
+						uri: "return",
+						name: "Conversion completed",
+						_meta: {
+							return: {
+								isCompleted: true,
+								isError: false,
+							},
+						},
+					},
+				];
+			} catch (err: unknown) {
+				const message = err instanceof Error ? err.message : String(err);
+				return [
+					{ type: "text", text: `Error converting temperature: ${message}` },
+					{
+						type: "resource_link",
+						uri: "return",
+						name: "Conversion error",
+						_meta: {
+							return: {
+								isCompleted: true,
+								isError: true,
+							},
+						},
+					},
+				];
+			}
+		},
+	}),
+];

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

@@ -0,0 +1,4 @@
+export * from "./forecast.js";
+export * from "./planner.js";
+export * from "./database.js";
+export * from "./summarizer.js";

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

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { ITool } from "../i-tool.js";
+
+const ExecutionNodeSchema = z.object({
+	nodeId: z.string().describe("Unique identifier (e.g., 'fetch_user_data')"),
+	instruction: z
+		.string()
+		.describe(
+			"Strict instruction. DO NOT hardcode/mock data. Reference injected dynamic variables (e.g., `vars.xyz`) directly in scripts/queries."
+		),
+	schemaOnly: z
+		.boolean()
+		.default(true)
+		.describe("TRUE for large datasets (SQL, APIs). FALSE for final markdown responses or strictly small payloads."),
+	tools: z.array(z.string()).describe("List of required tool names"),
+	dependsOn: z.array(z.string()).optional().describe("Array of nodeIds that must resolve before execution"),
+});
+
+const ExecutionPhaseSchema = z.object({
+	phaseId: z.string().describe("Sequential phase identifier (e.g., 'phase_1')"),
+	parallelNodes: z.array(ExecutionNodeSchema).describe("Nodes executing concurrently in this phase"),
+});
+
+const PlannerSchema = z.object({
+	isFeasible: z.boolean(),
+	queryClassification: z
+		.enum(["direct_answer", "requires_tools", "unclear"])
+		.describe(
+			"Classify intent. Use 'direct_answer' for abstract/general queries. Use 'requires_tools' for actionable workflows."
+		),
+	intentSummary: z.string(),
+	directResponse: z
+		.string()
+		.optional()
+		.describe("Populate ONLY if queryClassification is 'direct_answer'. Provides the final answer immediately."),
+	executionPhases: z
+		.array(ExecutionPhaseSchema)
+		.optional()
+		.describe("Populate ONLY if queryClassification is 'requires_tools'."),
+	abortReason: z
+		.string()
+		.optional()
+		.describe("Populate ONLY if isFeasible is false or queryClassification is 'unclear'."),
+});
+
+type PlannerInput = z.infer<typeof PlannerSchema>;
+
+export const PlannerTool: ITool[] = [
+	new ITool({
+		title: "planner",
+		description:
+			"Evaluates queries and architects execution plans. Can bypass planning for abstract queries to provide direct answers. RULES: 1. Ensure dependent nodes use dynamic variable injection. 2. Prevent data hallucination in dependent nodes.",
+		schema: PlannerSchema,
+		run: (input: PlannerInput) => {
+			try {
+				const { isFeasible, queryClassification, intentSummary, directResponse, executionPhases, abortReason } = input;
+
+				let payload;
+				let eventName = "";
+				let isError = false;
+
+				if (!isFeasible || queryClassification === "unclear") {
+					payload = { isFeasible, queryClassification, intentSummary, abortReason };
+					eventName = "ExecutionAborted";
+					isError = true;
+				} else if (queryClassification === "direct_answer") {
+					payload = { queryClassification, intentSummary, directResponse };
+					eventName = "DirectAnswerResolved";
+				} else {
+					payload = { isFeasible, queryClassification, intentSummary, executionPhases };
+					eventName = "PlanArchitected";
+				}
+
+				return [
+					{
+						type: "text",
+						text: JSON.stringify(payload, null, 2),
+					},
+					{
+						type: "resource_link",
+						uri: "return",
+						name: eventName,
+						_meta: {
+							return: {
+								isCompleted: true,
+								isError,
+							},
+						},
+					},
+				];
+			} catch (err: unknown) {
+				const message = err instanceof Error ? err.message : String(err);
+
+				return [
+					{
+						type: "text",
+						text: `Error processing plan: ${message}`,
+					},
+					{
+						type: "resource_link",
+						uri: "return",
+						name: "PlanFailed",
+						_meta: {
+							return: {
+								isCompleted: true,
+								isError: true,
+							},
+						},
+					},
+				];
+			}
+		},
+	}),
+];