startx 0.9.4 → 0.9.9

package/packages/aix/src/lib/convertor/variable-resolver.ts

@@ -0,0 +1,161 @@
+import { getQuickJS } from "quickjs-emscripten";
+
+export class VariableResolver {
+	static extractPlaceholders(text: string): string[] {
+		const matches = [...text.matchAll(/{{(.*?)}}/g)];
+		return matches.map(m => m[1]?.trim() || "");
+	}
+
+	static async evaluateInQuickJS(expression: string, context: Record<string, any>): Promise<any> {
+		const qjs = await getQuickJS();
+		const vm = qjs.newContext();
+
+		try {
+			const global = vm.global;
+
+			for (const scopeKey of Object.keys(context)) {
+				const scopeObject = vm.newObject();
+
+				for (const varKey of Object.keys(context?.[scopeKey])) {
+					const value = context?.[scopeKey]?.[varKey];
+					let valueHandle;
+
+					if (typeof value === "function") {
+						const fnCode = `(${value.toString()})`;
+						const fnEval = vm.evalCode(fnCode);
+						if (fnEval.error) {
+							console.warn(`Function eval failed: ${fnCode}`);
+							continue;
+						}
+						valueHandle = fnEval.value;
+					} else {
+						const json = value instanceof Date ? `"${value.toISOString()}"` : JSON.stringify(value);
+						const valEval = vm.evalCode(json);
+						if (valEval.error) {
+							console.warn(`Value eval failed: ${json}`);
+							continue;
+						}
+						valueHandle = valEval.value;
+					}
+
+					vm.setProp(scopeObject, varKey, valueHandle);
+					valueHandle.dispose();
+				}
+
+				vm.setProp(global, scopeKey, scopeObject);
+				scopeObject.dispose();
+			}
+
+			const wrappedExpr = `
+        (function() {
+          let val = ${expression};
+          while (typeof val === 'function') {
+            val = val();
+          }
+          return val;
+        })()
+      `;
+			const resultEval = vm.evalCode(wrappedExpr);
+			if (resultEval.error) {
+				console.warn(`Expression eval failed:`, resultEval.error);
+				return expression;
+			}
+
+			const result = vm.dump(resultEval.value);
+			resultEval.value.dispose();
+			return result;
+		} catch (error) {
+			console.warn("QuickJS error:", error);
+			return expression;
+		} finally {
+			vm.dispose();
+		}
+	}
+	static async resolveText(text: string, context: Record<string, any>): Promise<string> {
+		const placeholders = this.extractPlaceholders(text);
+
+		const replacements = await Promise.all(
+			placeholders.map(async expr => {
+				try {
+					const result = await this.evaluateInQuickJS(expr, context);
+					return {
+						expr,
+						result,
+						valid: result !== expr && result !== undefined,
+					};
+				} catch (e) {
+					return { expr, result: "", valid: false };
+				}
+			})
+		);
+
+		let resolved = text;
+		for (const { expr, result, valid } of replacements) {
+			if (valid) {
+				resolved = resolved.replace(`{{${expr}}}`, String(result));
+			}
+		}
+		return resolved;
+	}
+
+	static async resolveMessageVariables({
+		messages,
+		variables: variablesFromDb,
+	}: {
+		messages: Array<{ content: string; role: string; timestamp?: Date | null }>;
+		variables: Array<{
+			key: string;
+			type: "string" | "number" | "boolean" | "object" | "array" | "fn";
+			data: string;
+			access: "user" | "agent" | "system" | "message";
+		}>;
+	}) {
+		const messageVars = messages.flatMap(m => this.extractPlaceholders(m.content));
+		const allExpressions = [...new Set([...messageVars])];
+		const rootKeys = new Set(allExpressions.map(e => e.split(".")[0]));
+
+		const context: Record<string, any> = {
+			user: {},
+			agent: {},
+			system: {},
+			message: {},
+		};
+
+		for (const v of variablesFromDb) {
+			if (!rootKeys.has(v.access)) continue;
+
+			try {
+				let parsed: any;
+				if (v.type === "fn") {
+					parsed = eval(`(function() {
+            return (function() {
+              ${v.data}
+            });
+          })()`);
+				} else if (v.type === "object" || v.type === "array") {
+					parsed = JSON.parse(v.data);
+				} else if (v.type === "number") {
+					parsed = Number(v.data);
+				} else if (v.type === "boolean") {
+					parsed = v.data === "true";
+				} else {
+					parsed = v.data;
+				}
+
+				if (!context[v.access]) context[v.access] = {};
+				context[v.access][v.key] = parsed;
+			} catch (e) {
+				console.warn(`Failed to parse variable ${v.key}`, e);
+			}
+		}
+
+		const resolvedMessages = await Promise.all(
+			messages.map(async msg => ({
+				...msg,
+				content: await this.resolveText(msg.content, context),
+			}))
+		);
+
+		return resolvedMessages;
+	}
+}

package/packages/aix/src/lib/tokenizer/index.ts

@@ -0,0 +1 @@
+export * from "./tokenizer.js";

package/packages/aix/src/lib/tokenizer/tokenizer.ts

@@ -0,0 +1,42 @@
+import { getEncoding } from "js-tiktoken";
+
+// We get the encoding for a specific model, 'cl100k_base' is used by gpt-4, gpt-3.5-turbo, etc.
+// It's best practice to instantiate the encoder once and reuse it.
+const enc = getEncoding("cl100k_base");
+
+export class Tokenizer {
+	/**
+	 * Returns the total number of tokens in the text.
+	 * @param text The string to count tokens for.
+	 * @returns The number of tokens.
+	 */
+	static count(text: string): number {
+		return enc.encode(text).length;
+	}
+
+	/**
+	 * Checks if the text is within a given token limit.
+	 * @param text The string to check.
+	 * @param limit The token limit (defaults to 4096).
+	 * @returns True if the token count is within the limit, false otherwise.
+	 */
+	static isWithinLimit(text: string, limit: number = 4096): boolean {
+		// Note: We encode and check length instead of calling count()
+		// to avoid encoding the text twice if we needed the tokens later.
+		// If you only need a boolean, Tokenizer.count(text) <= limit is fine.
+		if (!text) return true;
+		const tokens = enc.encode(text);
+		return tokens.length <= limit;
+	}
+
+	/**
+	 * Returns the array of token integers.
+	 * @param text The string to tokenize.
+	 * @returns An array of token numbers.
+	 */
+	static getTokens(text: string): number[] {
+		const tokens = enc.encode(text);
+		// The result from encode() is a Uint32Array, so we convert it to a standard number array.
+		return Array.from(tokens);
+	}
+}

package/packages/aix/src/providers/ai-chat.ts

@@ -0,0 +1,25 @@
+import type { AiChatMessage, AiResource } from "./types.js";
+
+export class AiChat {
+	private messages: AiChatMessage[];
+	private currentMessage: string;
+	private resources: AiResource[] = [];
+	constructor(msgs?: AiChatMessage[]) {
+		this.messages = msgs || [];
+		this.currentMessage = "";
+	}
+	public getMessages() {
+		return this.messages;
+	}
+
+	public getResources() {
+		return this.resources;
+	}
+	public addMessage(msg: AiChatMessage) {
+		if (!this.currentMessage) this.currentMessage = msg.content;
+		this.messages.push(msg);
+	}
+	public addResource(resource: AiResource[]) {
+		this.resources.push(...resource);
+	}
+}

package/packages/aix/src/providers/ai-event.ts

@@ -0,0 +1,21 @@
+import type { ToolReturn } from "../tools/types.js";
+
+export type AiEventType = {
+	"ai.think.partial": string;
+	"ai.finish": string;
+	"tool.start": {
+		name: string;
+		args: any;
+	};
+	"tool.finish": ToolReturn;
+	"log": {
+		type: "info" | "warn" | "error";
+		message: string;
+		stack?: string;
+		meta?: Record<string, unknown>;
+	};
+	"token": {
+		input: number;
+		output: number;
+	};
+};

package/packages/aix/src/providers/ai-interface.ts

@@ -0,0 +1,236 @@
+import { IEvent, type IEventWithPayload } from "@repo/lib/events";
+import { encode } from "@toon-format/toon";
+import { nanoid } from "nanoid";
+import type z from "zod";
+
+import { AiChat } from "./ai-chat.js";
+import type { AiEventType } from "./ai-event.js";
+import { AiPrompt } from "./ai-prompt.js";
+import type { DefaultAiModels } from "./default-models.js";
+import type { AiChatMessage, AiProvider } from "./types.js";
+import { SchemaConvertor } from "../lib/convertor/schema-convertor.js";
+import { Tokenizer } from "../lib/tokenizer/tokenizer.js";
+import { ToolManager } from "../tools/tool-manager.js";
+import type { GenericTool, TInternal } from "../tools/types.js";
+export interface AiInterfaceConstructor<T extends AiProvider = AiProvider> {
+	preferences: {
+		name: string;
+		version?: string;
+		type: "manager" | "worker";
+		toolOnly: boolean;
+		temperature?: number;
+		seed?: number;
+	};
+	whitelistedTools?: string[];
+	model: (typeof DefaultAiModels)[T][number]["id"];
+	conversations: AiChatMessage[];
+	credentials: {
+		apiKey: string;
+		baseUrl?: string;
+	};
+	tokens?: Partial<Record<"maxLimit" | "current" | "total", { input: number; output: number }>> & {
+		minTokenToGenerateSchemaOnToolCall?: number;
+	};
+	internal?: TInternal;
+}
+export abstract class AiInterface<AI, P extends AiProvider> {
+	constructor(props: AiInterfaceConstructor) {
+		this.preferences = props.preferences;
+		this.tools = new ToolManager({ whitelist: props.whitelistedTools ?? [], events: this.event });
+		this.chats = new AiChat(props.conversations);
+		this.model = props.model;
+		this.credentials = props.credentials;
+		this.iInternal = props.internal;
+		const defaultToken = { input: 0, output: 0 };
+		const defaultMaxToken = { input: 20000, output: 4000 };
+		this.token = {
+			total: props.tokens?.total ?? defaultToken,
+			current: props.tokens?.current ?? defaultToken,
+			maxLimit: props.tokens?.maxLimit ?? defaultMaxToken,
+			minTokenToGenerateSchemaOnToolCall: props.tokens?.minTokenToGenerateSchemaOnToolCall ?? 1000,
+		};
+	}
+	abstract ai: AI;
+	protected abstract handleAi(): Promise<void>;
+	abstract listModels(): Promise<{
+		provider: string;
+		name: string;
+	}>;
+	protected model: (typeof DefaultAiModels)[P][number]["id"];
+	protected credentials: AiInterfaceConstructor["credentials"];
+	private iInternal: TInternal;
+	protected chats: AiChat;
+	public token: Required<AiInterfaceConstructor["tokens"]>;
+	public preferences: AiInterfaceConstructor["preferences"];
+	public tools: ToolManager;
+
+	protected callTool = async (props: {
+		name: string;
+		args: z.infer<GenericTool["schema"]>;
+		toolCallId?: string;
+		variablePlaceholders?: string[];
+	}) => {
+		// this.chats.addMessage({
+		// 	role: "assistant",
+		// 	content: `Calling tool ${props.name} with args ${JSON.stringify(props.args)}`,
+		// 	timestamp: new Date(),
+		// });
+
+		const res = await this.tools.callTool({
+			name: props.name,
+			args: props.args,
+			toolId: props.toolCallId ?? nanoid(),
+			internal: this.iInternal,
+		});
+
+		const usedVariables: string[] = props.variablePlaceholders ?? [];
+		this.chats.addResource(res.resources);
+		for (const e of res.content) {
+			switch (e.role) {
+				case "assistant":
+				case "system":
+				case "user": {
+					this.chats.addMessage(e);
+					break;
+				}
+				case "tool": {
+					const pString = e.content;
+					let data: object | undefined = undefined;
+					try {
+						data = JSON.parse(e.content) as object;
+					} catch {}
+					if (!data || res.isError || (!this.iInternal?.system?.schemaOnly && res.isCompleted)) {
+						this.chats.addMessage({
+							role: "tool",
+							content: AiPrompt.tool.call.success({
+								toolName: props.name,
+								isCompleted: res.isCompleted,
+								isError: res.isError,
+								args: JSON.stringify(props.args),
+								data: pString,
+							}),
+							tool_call_id: e.tool_call_id,
+							timestamp: new Date(),
+						});
+						continue;
+					}
+
+					const toon = encode(data);
+					const token = Tokenizer.count(toon);
+
+					if (token < (this.token?.minTokenToGenerateSchemaOnToolCall ?? 1000) && !this.iInternal?.system?.schemaOnly) {
+						this.chats.addMessage({
+							role: "tool",
+							content: AiPrompt.tool.call.success({
+								toolName: props.name,
+								isCompleted: res.isCompleted,
+								isError: res.isError,
+								args: JSON.stringify(props.args),
+								data: toon,
+							}),
+							tool_call_id: e.tool_call_id,
+							timestamp: new Date(),
+						});
+						continue;
+					}
+
+					const schema = SchemaConvertor.jsonToSchema(e.content);
+
+					if (!schema.schema) {
+						this.chats.addMessage({
+							role: "tool",
+							content: AiPrompt.tool.call.success({
+								toolName: props.name,
+								isCompleted: res.isCompleted,
+								isError: true,
+								args: JSON.stringify(props.args),
+								data: `Schema generation failed:`,
+							}),
+							tool_call_id: e.tool_call_id,
+							timestamp: new Date(),
+						});
+						continue;
+					}
+					let value = usedVariables?.[0] ?? `v_${nanoid().replace(/[^a-zA-Z0-9_]/g, "_")}`;
+					if (/^[0-9]/.test(value)) {
+						value = "_" + value;
+					}
+					usedVariables.pop();
+					this.iInternal?.vars?.set(value, {
+						data: JSON.stringify(data),
+						schema: schema.schema,
+					});
+					this.chats.addMessage({
+						role: "tool",
+						content: AiPrompt.tool.call.successSchema({
+							args: JSON.stringify(props.args),
+							toolName: props.name,
+							varName: `vars.${value}`,
+							schema: JSON.stringify(schema.schema),
+						}),
+						tool_call_id: e.tool_call_id,
+						timestamp: new Date(),
+					});
+					if (
+						!this.tools.whitelist.find(e => e === "execute_javascript") &&
+						this.tools.registered.has("execute_javascript")
+					) {
+						this.event.emit("log", {
+							type: "info",
+							message: `Tool execute_javascript is not whitelisted. Adding...`,
+						});
+
+						this.tools.whitelist.push("execute_javascript");
+						this.tools.tools.set("execute_javascript", this.tools.registered.get("execute_javascript")!);
+					}
+					break;
+				}
+			}
+		}
+		return {
+			isCompleted: res.isCompleted,
+			isError: res.isError,
+		};
+	};
+	private async syncModels() {
+		//  const models = await this.ai.
+	}
+	// Events
+	protected event: IEvent<AiEventType> = new IEvent();
+	public on<K extends keyof AiEventType>(event: K, handler: (payload: AiEventType[K]) => void) {
+		this.event.on(event, handler);
+		return () => this.event.off(event, handler);
+	}
+	public onEvery(handler: (e: IEventWithPayload<AiEventType>) => void) {
+		return this.event.onEvery(handler);
+	}
+	public async handleUserMessage(message: string) {
+		this.chats.addMessage({
+			role: "user",
+			content: message ?? "",
+			timestamp: new Date(),
+		});
+		this.event.on("token", ({ input, output }) => {
+			this.token!.total.input += input;
+			this.token!.total.output += output;
+
+			this.token!.current.input += input;
+			this.token!.current.output += output;
+
+			if (this.token!.total.input > this.token!.maxLimit.input) {
+				throw new Error("Token input limit exceeded");
+			}
+
+			if (this.token!.total.output > this.token!.maxLimit.output) {
+				throw new Error("Token output limit exceeded");
+			}
+		});
+		await this.handleAi();
+		return {
+			token: this.token!.total,
+			messages: this.chats.getMessages(),
+			resources: this.chats.getResources(),
+			vars: Array.from(this.iInternal?.vars.entries() || []),
+		};
+	}
+}

package/packages/aix/src/providers/ai-prompt.ts

@@ -0,0 +1,14 @@
+export const AiPrompt = {
+	tool: {
+		call: {
+			success: (props: { toolName: string; args: string; isCompleted?: boolean; data: string; isError?: boolean }) =>
+				props.isError
+					? `${props.toolName} with args ${props.args}  returned ERROR ${props.data}`
+					: props.isCompleted
+						? props.data
+						: `Tool ${props.toolName} with args ${props.args} returned ${props.data}`,
+			successSchema: (props: { toolName: string; args: string; varName: string; schema: string }) =>
+				`Tool call ${props.toolName} with args ${JSON.stringify(props.args)} responded with {{${props.varName}}\n\nSchema: ${JSON.stringify(props.schema)}\n\nCRITICAL INSTRUCTION: You MUST use the 'execute_javascript' tool to process this data. You must write valid JavaScript code with a 'return' statement.`,
+		},
+	},
+};