startx 1.0.1 → 1.0.3

package/packages/@repo/lib/src/session-module/index.ts

@@ -1,113 +1,10 @@
-import { RedisStore } from "@repo/redis";
+import { RedisUserSession } from "./redis-session.js";
 
-import { TokenModule } from "../extra/token-module.js";
-export const constants = {
-	sessionDuration: 60 * 60 * 6,
-};
-
-const accessTokenKey = (key: string) => `access_token:${key}`;
-const refreshTokenKey = (key: string) => `refresh_token:${key}`;
-const userTokensKey = (userId: string) => `session:${userId}`;
-export type SessionUser = {
-	id: string;
-	email: string;
-	fullName: string;
-	countries: string[];
-	department: string;
-	currentScenario?: string;
-	accessToken: string;
-};
-
-const userRedisStore = new RedisStore<SessionUser>({
-	namespace: "user-session",
-});
-
-const userRedisTokenStore = new RedisStore<{ accessToken: string; refreshToken: string }>({
-	namespace: "user-tokens",
-});
-
-export class UserSession {
-	static async getSessionUser(token: string) {
-		return await userRedisStore.get(accessTokenKey(token));
-	}
-
-	static async startSession(payload: Omit<SessionUser, "accessToken">) {
-		await UserSession.endSession(payload.id);
-
-		const accessToken = TokenModule.signAccessToken({
-			userID: payload.id,
-			email: payload.email,
-		});
-
-		const refreshToken = TokenModule.signRefreshToken({
-			userID: payload.id,
-			email: payload.email,
-		});
-
-		const sessionData: SessionUser = { ...payload, accessToken };
-
-		// store access token -> user
-		await userRedisStore.set(accessTokenKey(accessToken), sessionData, constants.sessionDuration);
-
-		// store user -> session (optional but useful)
-		await userRedisStore.set(payload.id, sessionData, constants.sessionDuration);
-
-		// store refresh token -> userId
-		await userRedisTokenStore.set(
-			refreshTokenKey(refreshToken),
-			{ accessToken, refreshToken },
-			constants.sessionDuration
-		);
-
-		// store user -> tokens
-		await userRedisTokenStore.set(
-			userTokensKey(payload.id),
-			{ accessToken, refreshToken },
-			constants.sessionDuration
-		);
-
-		return { accessToken, refreshToken };
+export const userSession = (type: "redis" | "pg") => {
+	switch (type) {
+		case "redis":
+			return new RedisUserSession();
+		default:
+			throw new Error("Unknown session type");
 	}
-
-	static async checkRefreshToken(refreshToken: string) {
-		const tokens = await userRedisTokenStore.get(refreshTokenKey(refreshToken));
-		return tokens ?? null;
-	}
-
-	static async updateAccessToken(payload: Omit<SessionUser, "accessToken">) {
-		const tokens = await this.getTokens(payload.id);
-		if (!tokens) return null;
-
-		const accessToken = tokens.accessToken;
-
-		await userRedisStore.set(
-			accessTokenKey(accessToken),
-			{ ...payload, accessToken },
-			constants.sessionDuration
-		);
-
-		return accessToken;
-	}
-
-	static async getTokens(userId: string) {
-		return await userRedisTokenStore.get(userTokensKey(userId));
-	}
-
-	static async logout(accessToken: string) {
-		const session = await userRedisStore.get(accessTokenKey(accessToken));
-		if (!session) return null;
-
-		await this.endSession(session.id);
-		return null;
-	}
-
-	static async endSession(userId: string) {
-		const tokens = await this.getTokens(userId);
-		if (!tokens) return;
-
-		await userRedisTokenStore.del(refreshTokenKey(tokens.refreshToken));
-		await userRedisStore.del(accessTokenKey(tokens.accessToken));
-		await userRedisTokenStore.del(userTokensKey(userId));
-		await userRedisStore.del(userId);
-	}
-}
+};

package/packages/@repo/lib/src/session-module/redis-session.ts

@@ -0,0 +1,44 @@
+import type { SessionUser } from "@repo/common/types/users";
+import { RedisStore } from "@repo/redis";
+import { IUserSession, type TokenPair } from "./i-session.js";
+
+export class RedisUserSession extends IUserSession {
+	private userStore: RedisStore<SessionUser>;
+	private tokenStore: RedisStore<TokenPair>;
+
+	constructor() {
+		super();
+		this.userStore = new RedisStore<SessionUser>({
+			namespace: "user-session",
+		});
+		this.tokenStore = new RedisStore<TokenPair>({
+			namespace: "user-tokens",
+		});
+	}
+
+	protected async setSessionData(key: string, data: SessionUser, ttl: number): Promise<void> {
+		await this.userStore.set(key, data, ttl);
+	}
+
+	protected async getSessionData(key: string): Promise<SessionUser | null> {
+		const data = await this.userStore.get(key);
+		return data ?? null;
+	}
+
+	protected async deleteSessionData(key: string): Promise<void> {
+		await this.userStore.del(key);
+	}
+
+	protected async setTokenData(key: string, data: TokenPair, ttl: number): Promise<void> {
+		await this.tokenStore.set(key, data, ttl);
+	}
+
+	protected async getTokenData(key: string): Promise<TokenPair | null> {
+		const data = await this.tokenStore.get(key);
+		return data ?? null;
+	}
+
+	protected async deleteTokenData(key: string): Promise<void> {
+		await this.tokenStore.del(key);
+	}
+}

package/packages/@repo/lib/tsconfig.json

@@ -1,7 +1,6 @@
 {
 	"extends": "typescript-config/tsconfig.node.json",
 	"compilerOptions": {
-		"baseUrl": "./src",
 		"jsx": "react"
 	},
 	"include": ["src/**/*.ts"]

package/packages/@repo/logger/package.json

@@ -23,7 +23,6 @@
 	},
 	"dependencies": {
 		"winston": "catalog:",
-		"dotenv": "catalog:",
 		"@repo/env": "workspace:*"
 	},
 	"startx": {

package/packages/@repo/logger/tsconfig.json

@@ -1,7 +1,7 @@
 {
 	"extends": "typescript-config/tsconfig.node.json",
 	"compilerOptions": {
-		"baseUrl": "./src"
+		// "baseUrl": "./src"
 	},
 	"include": ["src/**/*.ts"]
 }

package/packages/@repo/mail/tsconfig.json

@@ -3,7 +3,7 @@
 	"compilerOptions": {
 		"rootDir": ".",
 		"types": ["node", "react"],
-		"baseUrl": "src",
+		// "baseUrl": "src",
 		"jsx": "react",
 		"tsBuildInfoFile": "dist/typecheck.tsbuildinfo",
 		"experimentalDecorators": true,

package/packages/@repo/redis/tsconfig.json

@@ -3,7 +3,7 @@
 	"compilerOptions": {
 		"rootDir": ".",
 		"types": ["node"],
-		"baseUrl": "src",
+		// "baseUrl": "src",
 		"tsBuildInfoFile": "dist/typecheck.tsbuildinfo",
 		"experimentalDecorators": true,
 		"emitDecoratorMetadata": true

package/packages/aix/package.json

@@ -21,6 +21,8 @@
 		"vitest-config": "workspace:*"
 	},
 	"dependencies": {
+		"@aws-sdk/client-bedrock": "^3.1047.0",
+		"@aws-sdk/client-bedrock-runtime": "^3.1047.0",
 		"@repo/env": "workspace:*",
 		"@repo/lib": "workspace:*",
 		"@repo/logger": "workspace:*",

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

@@ -26,9 +26,9 @@ export interface AiInterfaceConstructor<T extends AiProvider = AiProvider> {
 	model: (typeof DefaultAiModels)[T][number]["id"];
 	conversations: AiChatMessage[];
 	credentials: {
-		apiKey: string;
+		apiKey?: string;
 		baseUrl?: string;
-	};
+	} & Record<string, string | undefined>;
 	tokens?: Partial<Record<"maxLimit" | "current" | "total", { input: number; output: number }>> & {
 		minTokenToGenerateSchemaOnToolCall?: number;
 	};
@@ -53,10 +53,10 @@ export abstract class AiInterface<AI, P extends AiProvider> {
 	}
 	abstract ai: AI;
 	protected abstract handleAi(): Promise<void>;
-	abstract listModels(): Promise<{
+	abstract listModels(): Promise<Array<{
 		provider: string;
 		name: string;
-	}>;
+	}>>;
 	protected model: (typeof DefaultAiModels)[P][number]["id"];
 	protected credentials: AiInterfaceConstructor["credentials"];
 	private iInternal: TInternal;

package/packages/aix/src/providers/bedrock/bedrock.ts

@@ -0,0 +1,261 @@
+import { BedrockClient as AwsBedrockClient, ListFoundationModelsCommand } from "@aws-sdk/client-bedrock";
+import {
+	BedrockRuntimeClient,
+	ConverseCommand,
+	type Tool,
+	type Message,
+	type SystemContentBlock,
+	type ToolUseBlock,
+} from "@aws-sdk/client-bedrock-runtime";
+
+import { AiInterface, type AiInterfaceConstructor } from "../ai-interface.js";
+
+type BedrockCredentials = {
+	accessKeyId: string;
+	secretAccessKey: string;
+	sessionToken?: string;
+	region: string;
+};
+
+export class BedrockClient extends AiInterface<BedrockRuntimeClient, "bedrock"> {
+	ai: BedrockRuntimeClient;
+	private controlPlane: AwsBedrockClient;
+
+	constructor(
+		props: AiInterfaceConstructor & {
+			credentials: BedrockCredentials;
+		}
+	) {
+		super(props);
+
+		const awsConfig = {
+			region: props.credentials.region,
+			credentials: {
+				accessKeyId: props.credentials.accessKeyId,
+				secretAccessKey: props.credentials.secretAccessKey,
+				sessionToken: props.credentials.sessionToken,
+			},
+		};
+
+		this.ai = new BedrockRuntimeClient(awsConfig);
+
+		this.controlPlane = new AwsBedrockClient(awsConfig);
+	}
+
+	async listModels() {
+		const models = await this.controlPlane.send(new ListFoundationModelsCommand({}));
+		return (
+			models.modelSummaries?.map(e => ({
+				provider: e.providerName!,
+				name: e.modelName!,
+			})) ?? []
+		);
+	}
+
+	private mapMessages(): { messages: Message[]; system: SystemContentBlock[] } {
+		const messages: Message[] = [];
+		const system: SystemContentBlock[] = [];
+
+		for (const msg of this.chats.getMessages()) {
+			if (msg.role === "system") {
+				system.push({ text: msg.content });
+				continue;
+			}
+
+			if (msg.role === "tool") {
+				messages.push({
+					role: "user",
+					content: [
+						{
+							toolResult: {
+								toolUseId: msg.tool_call_id,
+								content: [{ text: msg.content }],
+							},
+						},
+					],
+				});
+				continue;
+			}
+
+			const contentBlocks: Message["content"] = [];
+
+			if (msg.content) {
+				contentBlocks.push({ text: msg.content });
+			}
+
+			if (msg.role === "assistant" && "tool_calls" in msg) {
+				msg.tool_calls.forEach(tc => {
+					if (tc.type === "function") {
+						const func = tc as unknown as {
+							function: {
+								name: string;
+								arguments: string;
+							};
+						};
+						contentBlocks.push({
+							toolUse: {
+								toolUseId: tc.id,
+								name: func.function.name,
+								input: JSON.parse(func.function.arguments) as ToolUseBlock["input"],
+							},
+						});
+					}
+				});
+			}
+
+			messages.push({
+				role: msg.role === "assistant" ? "assistant" : "user",
+				content: contentBlocks,
+			});
+		}
+
+		return { messages, system };
+	}
+
+	private mapTools(): Tool[] {
+		return this.tools.getActiveTools().map(tool => ({
+			toolSpec: {
+				name: tool.name,
+				description: tool.description,
+				inputSchema: {
+					json: tool.input_schema.toJSONSchema(),
+				},
+			},
+		})) as Tool[];
+	}
+
+	async handleAi() {
+		const getCompletion = async () => {
+			try {
+				const tools = this.mapTools();
+				const { messages, system } = this.mapMessages();
+
+				const response = await this.ai.send(
+					new ConverseCommand({
+						modelId: this.model,
+						messages,
+						system: system.length ? system : undefined,
+						inferenceConfig: {
+							temperature: this.preferences.temperature,
+							maxTokens: this.preferences.maxCompletionTokens,
+						},
+						...(tools.length
+							? {
+									toolConfig: {
+										tools,
+										toolChoice: this.preferences.toolOnly ? { any: {} } : { auto: {} },
+									},
+								}
+							: {}),
+					})
+				);
+
+				if (response.usage) {
+					this.event.emit("token", {
+						input: response.usage.inputTokens ?? 0,
+						output: response.usage.outputTokens ?? 0,
+					});
+				}
+
+				return response;
+			} catch (error) {
+				const err = error as Error;
+
+				this.event.emit("log", {
+					type: "error",
+					message: err.message,
+					meta: err.cause as Record<string, unknown>,
+					stack: err.stack,
+				});
+
+				throw error;
+			}
+		};
+
+		let response = await getCompletion();
+
+		while (true) {
+			const output = response.output?.message;
+
+			if (!output) {
+				this.event.emit("log", {
+					type: "warn",
+					message: `⚠️ No output returned: ${JSON.stringify(response, null, 2)}`,
+				});
+				return;
+			}
+
+			let assistantText = "";
+			const toolCalls: Array<{
+				id: string;
+				type: "function";
+				function: {
+					name: string;
+					arguments: string;
+				};
+			}> = [];
+
+			for (const part of output.content ?? []) {
+				if ("text" in part && part.text) {
+					assistantText += part.text;
+				}
+
+				if ("toolUse" in part && part.toolUse) {
+					toolCalls.push({
+						id: part.toolUse.toolUseId!,
+						type: "function",
+						function: {
+							name: part.toolUse.name!,
+							arguments: JSON.stringify(part.toolUse.input ?? {}),
+						},
+					});
+				}
+			}
+
+			this.chats.addMessage({
+				role: "assistant",
+				content: assistantText,
+				tool_calls: toolCalls.length ? toolCalls : undefined,
+				timestamp: new Date(),
+			});
+
+			if (assistantText && toolCalls.length === 0) {
+				return;
+			}
+
+			if (!toolCalls.length) {
+				return;
+			}
+
+			for (const toolCall of toolCalls) {
+				let toolArgs: object = {};
+
+				try {
+					toolArgs = JSON.parse(toolCall.function.arguments) as Record<string, unknown>;
+				} catch (err) {
+					this.event.emit("log", {
+						type: "error",
+						message: `Tool: ${toolCall.function.name}⚠️ Failed to parse tool arguments: ${toolCall.function.arguments}`,
+						meta: { err },
+					});
+					continue;
+				}
+
+				const result = await this.callTool({
+					args: toolArgs as Record<string, unknown>,
+					name: toolCall.function.name,
+					toolCallId: toolCall.id,
+				});
+
+				if (result.isCompleted) {
+					return;
+				}
+				if (result.isError) {
+					return;
+				}
+			}
+
+			response = await getCompletion();
+		}
+	}
+}

package/packages/aix/src/providers/default-models.ts

@@ -458,6 +458,71 @@ export const DefaultAiModels = {
 			type: "text-completion",
 		},
 	],
+	bedrock: [
+		{
+			id: "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+			owner: "Anthropic",
+			contextWindowToken: 200000,
+			maxCompletionToken: 16384,
+			type: "text-completion",
+		},
+		{
+			id: "global.anthropic.claude-sonnet-4-5-20250929-v1:0",
+			owner: "Anthropic",
+			contextWindowToken: 200000,
+			maxCompletionToken: 16384,
+			type: "text-completion",
+		},
+		{
+			id: "us.anthropic.claude-opus-4-6-v1",
+			owner: "Anthropic",
+			contextWindowToken: 200000,
+			maxCompletionToken: 16384,
+			type: "text-completion",
+		},
+		{
+			id: "us.anthropic.claude-haiku-4-5-20251001-v1:0",
+			owner: "Anthropic",
+			contextWindowToken: 200000,
+			maxCompletionToken: 16384,
+			type: "text-completion",
+		},
+		{
+			id: "amazon.nova-pro-v1:0",
+			owner: "Amazon",
+			contextWindowToken: 300000,
+			maxCompletionToken: 5120,
+			type: "text-completion",
+		},
+		{
+			id: "amazon.nova-lite-v1:0",
+			owner: "Amazon",
+			contextWindowToken: 300000,
+			maxCompletionToken: 5120,
+			type: "text-completion",
+		},
+		{
+			id: "openai.gpt-oss-120b-1:0",
+			owner: "OpenAI",
+			contextWindowToken: 128000,
+			maxCompletionToken: 16384,
+			type: "text-completion",
+		},
+		{
+			id: "openai.gpt-oss-20b-1:0",
+			owner: "OpenAI",
+			contextWindowToken: 128000,
+			maxCompletionToken: 16384,
+			type: "text-completion",
+		},
+		// {
+		// 	id: "cohere.embed-english-v3",
+		// 	owner: "Cohere",
+		// 	contextWindowToken: 2048,
+		// 	maxCompletionToken: 0,
+		// 	type: "embedding",
+		// },
+	],
 } as const satisfies Record<
 	AiProvider,
 	ReadonlyArray<{

package/packages/aix/src/providers/openai/openai.ts

@@ -7,8 +7,8 @@ export class OpenAIClient extends AiInterface<OpenAI, "openAi"> {
 		this.ai = new OpenAI({ apiKey: props.credentials.apiKey, baseURL: props.credentials.baseUrl });
 	}
 	ai: OpenAI;
-	async listModels(): Promise<any> {
-		return await this.ai.models.list();
+	async listModels() {
+		return (await this.ai.models.list()).data.map(e => ({ name: e.id, provider: "openAi" }));
 	}
 	async handleAi() {
 		const getCompletion = async (retries = 1): Promise<OpenAI.Chat.ChatCompletion> => {

package/packages/aix/src/providers/providers.ts

@@ -1,4 +1,5 @@
 import type { AiInterfaceConstructor } from "./ai-interface.js";
+import { BedrockClient } from "./bedrock/bedrock.js";
 import { OpenAIClient } from "./openai/openai.js";
 import type { AiProvider } from "./types.js";
 export function aiProvider<T extends AiProvider>(type: T) {
@@ -32,6 +33,16 @@ export function aiProvider<T extends AiProvider>(type: T) {
 				});
 			case "cloudflare":
 				return new OpenAIClient(props);
+			case "bedrock":
+				return new BedrockClient({
+					...props,
+					credentials: {
+						accessKeyId: props.credentials.accessKeyId!,
+						secretAccessKey: props.credentials.secretAccessKey!,
+						sessionToken: props.credentials.sessionToken,
+						region: props.credentials.region!,
+					},
+				});
 			default:
 				throw new Error("Provider not implemented");
 		}

package/packages/aix/src/providers/types.ts

@@ -1,4 +1,4 @@
-export type AiProvider = "groq" | "openAi" | "cloudflare" | "gemini" | "anthropic" | "cerebras";
+export type AiProvider = "groq" | "openAi" | "cloudflare" | "gemini" | "anthropic" | "cerebras" | "bedrock";
 export type AiProviderModelType = "text-completion" | "image-generation" | "audio-generation";
 
 export type AiChatRole = "user" | "system" | "assistant";

package/packages/{constants → common}/package.json

@@ -1,5 +1,5 @@
 {
-	"name": "constants",
+	"name": "@repo/common",
 	"version": "0.12.0",
 	"type": "module",
 
@@ -13,7 +13,9 @@
 		"lint:fix": "eslint . --fix",
 		"watch": "tsc -p tsconfig.build.json --watch"
 	},
-	"exports": "./src/index.ts",
+	"exports": {
+		"./*": "./src/*.ts"
+	},
 	"devDependencies": {
 		"typescript-config": "workspace:*",
 		"eslint-config": "workspace:*",

package/packages/{constants/src/index.ts → common/src/constants.ts}

@@ -1,8 +1,3 @@
-export * from "./api.js";
-
-export { Time } from "./time.js";
-
 export const MIN_PASSWORD_CHAR_LENGTH = 8;
-
 export const MAX_PASSWORD_CHAR_LENGTH = 64;
 export const ping = "pong";

package/packages/common/src/types/users.ts

@@ -0,0 +1,10 @@
+export type SessionUserRole = "user" | "admin";
+
+export type SessionUser = {
+	id: string;
+	email: string;
+	fullName: string;
+	role: SessionUserRole;
+	currentProfile: SessionUserRole;
+	accessToken: string;
+};

package/packages/{constants → common}/tsconfig.json

@@ -1,7 +1,4 @@
 {
 	"extends": "typescript-config/tsconfig.common.json",
-	"compilerOptions": {
-		"baseUrl": "./src"
-	},
 	"include": ["src/**/*.ts"]
 }