@agimon-ai/imagine-mcp 0.2.0

package/dist/stdio-CuIrQe3m.mjs

@@ -0,0 +1,891 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { basename, extname, resolve } from "node:path";
+import fetch from "node-fetch";
+import { createApi } from "unsplash-js";
+import { z } from "zod";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express from "express";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+//#region src/utils.ts
+/**
+* Normalizes a file path by handling escaped characters and spaces
+*
+* This function handles cases like 'a\ name.png' by converting them to 'a name.png'
+*/
+function normalizeFilePath(filePath) {
+	let normalizedPath = filePath.replace(/\\+ /g, " ");
+	normalizedPath = normalizedPath.replace(/\\+'/g, "'").replace(/\\+"/g, "\"").replace(/\\+`/g, "`").replace(/\\+\(/g, "(").replace(/\\+\)/g, ")").replace(/\\+\[/g, "[").replace(/\\+\]/g, "]").replace(/\\+\{/g, "{").replace(/\\+\}/g, "}");
+	return normalizedPath;
+}
+
+//#endregion
+//#region src/services/ImageReader.ts
+const DEFAULT_MIME_TYPE = "application/octet-stream";
+const MIME_BY_EXTENSION = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".bmp": "image/bmp",
+	".svg": "image/svg+xml",
+	".heic": "image/heic",
+	".heif": "image/heif"
+};
+var ImageReader = class {
+	async readImage(source, options = {}) {
+		const imageSource = await this.resolveImageSource(source);
+		const sha256 = createHash("sha256").update(imageSource.data).digest("hex");
+		const result = {
+			source: imageSource.source,
+			sourceType: imageSource.sourceType,
+			mimeType: imageSource.mimeType,
+			sizeBytes: imageSource.sizeBytes,
+			sha256
+		};
+		if (imageSource.sourceType !== "data-uri") result.fileName = basename(imageSource.source);
+		if (options.includeBase64) result.base64 = imageSource.data.toString("base64");
+		return result;
+	}
+	async resolveImageSource(source) {
+		const trimmed = source.trim();
+		if (!trimmed) throw new McpError(ErrorCode.InvalidParams, "Image source cannot be empty.");
+		if (trimmed.startsWith("data:")) return this.resolveDataUri(trimmed);
+		if (/^https?:\/\//i.test(trimmed)) return this.resolveRemoteImage(trimmed);
+		return this.resolveFile(trimmed);
+	}
+	async resolveFile(filePath) {
+		const normalizedPath = resolve(normalizeFilePath(filePath));
+		try {
+			await access(normalizedPath, constants.F_OK);
+		} catch (error) {
+			throw new McpError(ErrorCode.InvalidParams, `Image file not found at path: ${filePath}`);
+		}
+		let data;
+		try {
+			data = await readFile(normalizedPath);
+		} catch (error) {
+			throw new McpError(ErrorCode.InternalError, `Failed to read image file: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		return {
+			source: normalizedPath,
+			sourceType: "file",
+			mimeType: MIME_BY_EXTENSION[extname(normalizedPath).toLowerCase()] || DEFAULT_MIME_TYPE,
+			sizeBytes: data.length,
+			data
+		};
+	}
+	async resolveRemoteImage(url) {
+		try {
+			const response = await fetch(url, { redirect: "follow" });
+			if (!response.ok) throw new McpError(ErrorCode.InvalidParams, `Failed to fetch image from URL: ${url} (${response.status} ${response.statusText})`);
+			const arrayBuffer = await response.arrayBuffer();
+			const data = Buffer.from(arrayBuffer);
+			const contentType = response.headers.get("content-type")?.split(";")[0];
+			const fileName = basename(new URL(url).pathname || "image");
+			return {
+				source: url,
+				sourceType: "url",
+				mimeType: contentType ?? MIME_BY_EXTENSION[extname(fileName)] ?? DEFAULT_MIME_TYPE,
+				sizeBytes: data.length,
+				data
+			};
+		} catch (error) {
+			if (error instanceof McpError) throw error;
+			throw new McpError(ErrorCode.InternalError, `Failed to download image from URL: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	resolveDataUri(dataUri) {
+		const commaIndex = dataUri.indexOf(",");
+		if (commaIndex === -1 || commaIndex === dataUri.length - 1) throw new McpError(ErrorCode.InvalidParams, "Invalid data URI format. Expected `data:[<mime>];base64,<payload>`.");
+		const metadata = dataUri.slice(5, commaIndex).toLowerCase();
+		const payload = dataUri.slice(commaIndex + 1);
+		const isBase64 = metadata.includes("base64");
+		const declaredMimeType = metadata.split(";")[0] || DEFAULT_MIME_TYPE;
+		try {
+			const data = isBase64 ? Buffer.from(payload, "base64") : Buffer.from(decodeURIComponent(payload));
+			return {
+				source: dataUri,
+				sourceType: "data-uri",
+				mimeType: declaredMimeType || DEFAULT_MIME_TYPE,
+				sizeBytes: data.length,
+				data
+			};
+		} catch (error) {
+			throw new McpError(ErrorCode.InvalidParams, `Failed to decode data URI payload: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/tools/ReadImageTool.ts
+var ReadImageTool = class ReadImageTool {
+	static TOOL_NAME = "read-image";
+	service = new ImageReader();
+	getDefinition() {
+		return {
+			name: ReadImageTool.TOOL_NAME,
+			description: "Read an image from a local path, URL, or data URI and return metadata.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					source: {
+						type: "string",
+						minLength: 1,
+						description: "Image source as a local path, HTTP(S) URL, or data URI."
+					},
+					includeBase64: {
+						type: "boolean",
+						description: "Whether to include base64-encoded output.",
+						default: false
+					}
+				},
+				required: ["source"],
+				additionalProperties: false
+			}
+		};
+	}
+	async execute(input) {
+		try {
+			if (!input || typeof input !== "object") throw new McpError(ErrorCode.InvalidParams, "Tool input must be an object.");
+			const payload = input;
+			const source = payload.source;
+			const includeBase64 = payload.includeBase64;
+			if (!source || typeof source !== "string" || source.trim().length === 0) throw new McpError(ErrorCode.InvalidParams, "source must be a non-empty string.");
+			if (includeBase64 !== void 0 && typeof includeBase64 !== "boolean") throw new McpError(ErrorCode.InvalidParams, "includeBase64 must be a boolean.");
+			const options = { includeBase64 };
+			const result = await this.service.readImage(source, options);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/imagineEnvSchema.ts
+/**
+* Environment variable schema for imagine-mcp
+*
+* Following Agiflow naming conventions:
+* - Service credentials use provider-specific prefixes
+* - Upload service selection uses UPLOAD_SERVICE
+*/
+const envSchema = z.object({
+	UPLOAD_SERVICE: z.enum([
+		"s3",
+		"cloudflare",
+		"gcloud"
+	]).optional().default("s3"),
+	S3_BUCKET: z.string().optional(),
+	AWS_ACCESS_KEY_ID: z.string().optional(),
+	AWS_SECRET_ACCESS_KEY: z.string().optional(),
+	S3_REGION: z.string().optional().default("us-east-1"),
+	S3_ENDPOINT: z.string().url("S3_ENDPOINT must be a valid URL").optional(),
+	CLOUDFLARE_R2_BUCKET: z.string().optional(),
+	CLOUDFLARE_R2_ACCESS_KEY_ID: z.string().optional(),
+	CLOUDFLARE_R2_SECRET_ACCESS_KEY: z.string().optional(),
+	CLOUDFLARE_R2_REGION: z.string().optional().default("auto"),
+	CLOUDFLARE_R2_ENDPOINT: z.string().url("CLOUDFLARE_R2_ENDPOINT must be a valid URL").optional(),
+	GCLOUD_BUCKET: z.string().optional(),
+	GCLOUD_PROJECT_ID: z.string().optional(),
+	GCLOUD_CREDENTIALS_PATH: z.string().optional(),
+	UNSPLASH_ACCESS_KEY: z.string().optional()
+}).refine((data) => {
+	if (data.AWS_ACCESS_KEY_ID || data.AWS_SECRET_ACCESS_KEY) return data.AWS_ACCESS_KEY_ID && data.AWS_SECRET_ACCESS_KEY;
+	return true;
+}, {
+	message: "Both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY must be provided together",
+	path: ["AWS_ACCESS_KEY_ID"]
+});
+
+//#endregion
+//#region src/config.ts
+/**
+* Centralized configuration service for imagine-mcp
+*
+* Validates environment variables at startup and provides
+* type-safe access to configuration throughout the application.
+*/
+var ConfigService = class ConfigService {
+	static instance;
+	config;
+	constructor() {
+		try {
+			this.config = envSchema.parse(process.env);
+		} catch (error) {
+			if (error instanceof z.ZodError) {
+				const errorMessage = error.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+				throw new McpError(ErrorCode.InternalError, `Environment configuration validation failed: ${errorMessage}`);
+			}
+			throw error;
+		}
+	}
+	/**
+	* Get the singleton instance of ConfigService
+	*/
+	static getInstance() {
+		if (!ConfigService.instance) ConfigService.instance = new ConfigService();
+		return ConfigService.instance;
+	}
+	/**
+	* Get the validated configuration
+	*/
+	getConfig() {
+		return this.config;
+	}
+	/**
+	* Get S3 configuration
+	*/
+	getS3Config() {
+		return {
+			bucket: this.config.S3_BUCKET,
+			accessKeyId: this.config.AWS_ACCESS_KEY_ID,
+			secretAccessKey: this.config.AWS_SECRET_ACCESS_KEY,
+			region: this.config.S3_REGION,
+			endpoint: this.config.S3_ENDPOINT
+		};
+	}
+	/**
+	* Get Cloudflare R2 configuration
+	*/
+	getCloudflareConfig() {
+		return {
+			bucket: this.config.CLOUDFLARE_R2_BUCKET,
+			accessKeyId: this.config.CLOUDFLARE_R2_ACCESS_KEY_ID,
+			secretAccessKey: this.config.CLOUDFLARE_R2_SECRET_ACCESS_KEY,
+			region: this.config.CLOUDFLARE_R2_REGION,
+			endpoint: this.config.CLOUDFLARE_R2_ENDPOINT
+		};
+	}
+	/**
+	* Get Google Cloud Storage configuration
+	*/
+	getGCloudConfig() {
+		return {
+			bucket: this.config.GCLOUD_BUCKET,
+			projectId: this.config.GCLOUD_PROJECT_ID,
+			credentialsPath: this.config.GCLOUD_CREDENTIALS_PATH
+		};
+	}
+	/**
+	* Get the default upload service
+	*/
+	getUploadService() {
+		return this.config.UPLOAD_SERVICE;
+	}
+	/**
+	* Get Unsplash API configuration
+	*/
+	getUnsplashConfig() {
+		return { accessKey: this.config.UNSPLASH_ACCESS_KEY };
+	}
+	/**
+	* Validate that required credentials exist for a specific service
+	*/
+	validateServiceConfig(service) {
+		switch (service) {
+			case "s3":
+				if (!this.config.S3_BUCKET) throw new McpError(ErrorCode.InvalidParams, "S3_BUCKET is required for S3 upload service");
+				break;
+			case "cloudflare":
+				if (!this.config.CLOUDFLARE_R2_BUCKET) throw new McpError(ErrorCode.InvalidParams, "CLOUDFLARE_R2_BUCKET is required for Cloudflare upload service");
+				if (!this.config.CLOUDFLARE_R2_ACCESS_KEY_ID || !this.config.CLOUDFLARE_R2_SECRET_ACCESS_KEY) throw new McpError(ErrorCode.InvalidParams, "CLOUDFLARE_R2_ACCESS_KEY_ID and CLOUDFLARE_R2_SECRET_ACCESS_KEY are required for Cloudflare upload service");
+				if (!this.config.CLOUDFLARE_R2_ENDPOINT) throw new McpError(ErrorCode.InvalidParams, "CLOUDFLARE_R2_ENDPOINT is required for Cloudflare upload service");
+				break;
+			case "gcloud":
+				if (!this.config.GCLOUD_BUCKET) throw new McpError(ErrorCode.InvalidParams, "GCLOUD_BUCKET is required for Google Cloud upload service");
+				if (!this.config.GCLOUD_PROJECT_ID) throw new McpError(ErrorCode.InvalidParams, "GCLOUD_PROJECT_ID is required for Google Cloud upload service");
+				break;
+		}
+	}
+};
+const config = ConfigService.getInstance();
+
+//#endregion
+//#region src/services/UnsplashService.ts
+/**
+* UnsplashService
+*
+* DESIGN PATTERNS:
+* - Service pattern for business logic encapsulation
+* - Single responsibility principle
+*
+* CODING STANDARDS:
+* - Use async/await for asynchronous operations
+* - Throw descriptive errors for error cases
+* - Keep methods focused and well-named
+* - Document complex logic with comments
+*
+* AVOID:
+* - Mixing concerns (keep focused on single domain)
+* - Direct tool implementation (services should be tool-agnostic)
+*/
+var UnsplashService = class {
+	api;
+	constructor(accessKey) {
+		const unsplashConfig = config.getUnsplashConfig();
+		const apiKey = accessKey || unsplashConfig.accessKey;
+		if (!apiKey) throw new Error("Unsplash API key is required. Set UNSPLASH_ACCESS_KEY environment variable.");
+		this.api = createApi({ accessKey: apiKey });
+	}
+	async searchImages(params) {
+		try {
+			const result = await this.api.search.getPhotos({
+				query: params.query,
+				page: params.page || 1,
+				perPage: params.perPage || 10,
+				orientation: params.orientation,
+				color: params.color
+			});
+			if (result.errors) throw new Error(`Unsplash API error: ${result.errors.join(", ")}`);
+			if (!result.response) throw new Error("No response from Unsplash API");
+			return result.response.results.map((photo) => ({
+				id: photo.id,
+				description: photo.description,
+				alt_description: photo.alt_description,
+				urls: {
+					raw: photo.urls.raw,
+					full: photo.urls.full,
+					regular: photo.urls.regular,
+					small: photo.urls.small,
+					thumb: photo.urls.thumb
+				},
+				links: {
+					html: photo.links.html,
+					download: photo.links.download
+				},
+				user: {
+					name: photo.user.name,
+					username: photo.user.username,
+					portfolio_url: photo.user.portfolio_url
+				},
+				width: photo.width,
+				height: photo.height,
+				color: photo.color || "#000000",
+				likes: photo.likes
+			}));
+		} catch (error) {
+			throw new Error(`Failed to search Unsplash images: ${error instanceof Error ? error.message : "Unknown error"}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/tools/UnsplashSearchTool.ts
+var UnsplashSearchTool = class UnsplashSearchTool {
+	static TOOL_NAME = "unsplash_search";
+	service;
+	accessKey;
+	constructor(accessKey) {
+		this.accessKey = accessKey;
+		this.service = null;
+	}
+	getService() {
+		if (!this.service) this.service = new UnsplashService(this.accessKey);
+		return this.service;
+	}
+	getDefinition() {
+		return {
+			name: UnsplashSearchTool.TOOL_NAME,
+			description: "Search for stock images from Unsplash by keyword and return image URLs with metadata",
+			inputSchema: {
+				type: "object",
+				properties: {
+					query: {
+						type: "string",
+						description: "Search query (e.g., \"sunset\", \"technology\", \"nature\")"
+					},
+					perPage: {
+						type: "number",
+						description: "Number of results per page (1-30, default: 10)",
+						minimum: 1,
+						maximum: 30
+					},
+					page: {
+						type: "number",
+						description: "Page number for pagination (default: 1)",
+						minimum: 1
+					},
+					orientation: {
+						type: "string",
+						enum: [
+							"landscape",
+							"portrait",
+							"squarish"
+						],
+						description: "Filter by photo orientation"
+					},
+					color: {
+						type: "string",
+						enum: [
+							"black_and_white",
+							"black",
+							"white",
+							"yellow",
+							"orange",
+							"red",
+							"purple",
+							"magenta",
+							"green",
+							"teal",
+							"blue"
+						],
+						description: "Filter by photo color"
+					}
+				},
+				required: ["query"],
+				additionalProperties: false
+			}
+		};
+	}
+	async execute(input) {
+		try {
+			const images = await this.getService().searchImages({
+				query: input.query,
+				perPage: input.perPage,
+				page: input.page,
+				orientation: input.orientation,
+				color: input.color
+			});
+			if (images.length === 0) return { content: [{
+				type: "text",
+				text: `No images found for query: "${input.query}"`
+			}] };
+			const formattedResults = images.map((img, index) => {
+				return `
+📷 **Image ${index + 1}**
+- **ID**: ${img.id}
+- **Description**: ${img.alt_description || img.description || "No description"}
+- **Photographer**: ${img.user.name} (@${img.user.username})
+- **Dimensions**: ${img.width}x${img.height}px
+- **Color**: ${img.color}
+- **Likes**: ${img.likes}
+
+**URLs**:
+- Full: ${img.urls.full}
+- Regular: ${img.urls.regular}
+- Small: ${img.urls.small}
+- Thumbnail: ${img.urls.thumb}
+
+**Links**:
+- View on Unsplash: ${img.links.html}
+- Download: ${img.links.download}
+${img.user.portfolio_url ? `- Photographer Portfolio: ${img.user.portfolio_url}` : ""}
+`.trim();
+			}).join("\n\n" + "-".repeat(80) + "\n\n");
+			return { content: [{
+				type: "text",
+				text: `Found ${images.length} image(s) for "${input.query}":\n\n${formattedResults}`
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/server/index.ts
+/**
+* MCP Server Setup
+*
+* DESIGN PATTERNS:
+* - Factory pattern for server creation
+* - Tool registration pattern
+*
+* CODING STANDARDS:
+* - Register all tools, resources, and prompts here
+* - Keep server setup modular and extensible
+* - Import tools from ../tools/ and register them in the handlers
+*/
+function createServer() {
+	const server = new Server({
+		name: "imagine-mcp",
+		version: "0.1.0"
+	}, { capabilities: { tools: {} } });
+	const unsplashSearchTool = new UnsplashSearchTool();
+	const readImageTool = new ReadImageTool();
+	server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [unsplashSearchTool.getDefinition(), readImageTool.getDefinition()] }));
+	server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const { name, arguments: args } = request.params;
+		if (name === UnsplashSearchTool.TOOL_NAME) return await unsplashSearchTool.execute(args);
+		if (name === ReadImageTool.TOOL_NAME) return await readImageTool.execute(args);
+		return {
+			content: [{
+				type: "text",
+				text: `Unknown tool: ${name}`
+			}],
+			isError: true
+		};
+	});
+	return server;
+}
+
+//#endregion
+//#region src/transports/http.ts
+/**
+* HTTP Transport Handler
+*
+* DESIGN PATTERNS:
+* - Transport handler pattern implementing TransportHandler interface
+* - Session management for stateful connections
+* - Streamable HTTP protocol (2025-03-26) with resumability support
+* - Factory pattern for creating MCP server instances per session
+*
+* CODING STANDARDS:
+* - Use async/await for all asynchronous operations
+* - Implement proper session lifecycle management
+* - Handle errors gracefully with appropriate HTTP status codes
+* - Provide health check endpoint for monitoring
+* - Clean up resources on shutdown
+*
+* AVOID:
+* - Sharing MCP server instances across sessions (use factory pattern)
+* - Forgetting to clean up sessions on disconnect
+* - Missing error handling for request processing
+* - Hardcoded configuration (use TransportConfig)
+*/
+/**
+* HTTP session manager
+*/
+var HttpFullSessionManager = class {
+	sessions = /* @__PURE__ */ new Map();
+	getSession(sessionId) {
+		return this.sessions.get(sessionId);
+	}
+	setSession(sessionId, transport, server) {
+		this.sessions.set(sessionId, {
+			transport,
+			server
+		});
+	}
+	deleteSession(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (session) session.server.close();
+		this.sessions.delete(sessionId);
+	}
+	hasSession(sessionId) {
+		return this.sessions.has(sessionId);
+	}
+	clear() {
+		for (const session of this.sessions.values()) session.server.close();
+		this.sessions.clear();
+	}
+};
+/**
+* HTTP transport handler using Streamable HTTP (protocol version 2025-03-26)
+* Provides stateful session management with resumability support
+*/
+var HttpTransportHandler = class {
+	serverFactory;
+	app;
+	server = null;
+	sessionManager;
+	config;
+	constructor(serverFactory, config$1) {
+		this.serverFactory = typeof serverFactory === "function" ? serverFactory : () => serverFactory;
+		this.app = express();
+		this.sessionManager = new HttpFullSessionManager();
+		this.config = {
+			mode: config$1.mode,
+			port: config$1.port ?? 3e3,
+			host: config$1.host ?? "localhost"
+		};
+		this.setupMiddleware();
+		this.setupRoutes();
+	}
+	setupMiddleware() {
+		this.app.use(express.json());
+	}
+	setupRoutes() {
+		this.app.post("/mcp", async (req, res) => {
+			await this.handlePostRequest(req, res);
+		});
+		this.app.get("/mcp", async (req, res) => {
+			await this.handleGetRequest(req, res);
+		});
+		this.app.delete("/mcp", async (req, res) => {
+			await this.handleDeleteRequest(req, res);
+		});
+		this.app.get("/health", (_req, res) => {
+			res.json({
+				status: "ok",
+				transport: "http"
+			});
+		});
+	}
+	async handlePostRequest(req, res) {
+		const sessionId = req.headers["mcp-session-id"];
+		let transport;
+		if (sessionId && this.sessionManager.hasSession(sessionId)) transport = this.sessionManager.getSession(sessionId).transport;
+		else if (!sessionId && isInitializeRequest(req.body)) {
+			const mcpServer = this.serverFactory();
+			transport = new StreamableHTTPServerTransport({
+				sessionIdGenerator: () => randomUUID(),
+				enableJsonResponse: true,
+				onsessioninitialized: (sessionId$1) => {
+					this.sessionManager.setSession(sessionId$1, transport, mcpServer);
+				}
+			});
+			transport.onclose = () => {
+				if (transport.sessionId) this.sessionManager.deleteSession(transport.sessionId);
+			};
+			await mcpServer.connect(transport);
+		} else {
+			res.status(400).json({
+				jsonrpc: "2.0",
+				error: {
+					code: -32e3,
+					message: "Bad Request: No valid session ID provided"
+				},
+				id: null
+			});
+			return;
+		}
+		await transport.handleRequest(req, res, req.body);
+	}
+	async handleGetRequest(req, res) {
+		const sessionId = req.headers["mcp-session-id"];
+		if (!sessionId || !this.sessionManager.hasSession(sessionId)) {
+			res.status(400).send("Invalid or missing session ID");
+			return;
+		}
+		await this.sessionManager.getSession(sessionId).transport.handleRequest(req, res);
+	}
+	async handleDeleteRequest(req, res) {
+		const sessionId = req.headers["mcp-session-id"];
+		if (!sessionId || !this.sessionManager.hasSession(sessionId)) {
+			res.status(400).send("Invalid or missing session ID");
+			return;
+		}
+		await this.sessionManager.getSession(sessionId).transport.handleRequest(req, res);
+		this.sessionManager.deleteSession(sessionId);
+	}
+	async start() {
+		return new Promise((resolve$1, reject) => {
+			try {
+				this.server = this.app.listen(this.config.port, this.config.host, () => {
+					process.stderr.write(`imagine-mcp MCP server started on http://${this.config.host}:${this.config.port}/mcp\n`);
+					process.stderr.write(`Health check: http://${this.config.host}:${this.config.port}/health\n`);
+					resolve$1();
+				});
+				this.server.on("error", (error) => {
+					reject(error);
+				});
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+	async stop() {
+		return new Promise((resolve$1, reject) => {
+			if (this.server) {
+				this.sessionManager.clear();
+				this.server.close((err) => {
+					if (err) reject(err);
+					else {
+						this.server = null;
+						resolve$1();
+					}
+				});
+			} else resolve$1();
+		});
+	}
+	getPort() {
+		return this.config.port;
+	}
+	getHost() {
+		return this.config.host;
+	}
+};
+
+//#endregion
+//#region src/transports/sse.ts
+/**
+* Session manager for SSE transports
+*/
+var SseSessionManager = class {
+	sessions = /* @__PURE__ */ new Map();
+	getSession(sessionId) {
+		return this.sessions.get(sessionId)?.transport;
+	}
+	setSession(sessionId, transport, server) {
+		this.sessions.set(sessionId, {
+			transport,
+			server
+		});
+	}
+	deleteSession(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (session) session.server.close();
+		this.sessions.delete(sessionId);
+	}
+	hasSession(sessionId) {
+		return this.sessions.has(sessionId);
+	}
+	clear() {
+		for (const session of this.sessions.values()) session.server.close();
+		this.sessions.clear();
+	}
+};
+/**
+* SSE (Server-Sent Events) transport handler
+* Legacy transport for backwards compatibility (protocol version 2024-11-05)
+* Uses separate endpoints: /sse for SSE stream (GET) and /messages for client messages (POST)
+*/
+var SseTransportHandler = class {
+	serverFactory;
+	app;
+	server = null;
+	sessionManager;
+	config;
+	constructor(serverFactory, config$1) {
+		this.serverFactory = typeof serverFactory === "function" ? serverFactory : () => serverFactory;
+		this.app = express();
+		this.sessionManager = new SseSessionManager();
+		this.config = {
+			mode: config$1.mode,
+			port: config$1.port ?? 3e3,
+			host: config$1.host ?? "localhost"
+		};
+		this.setupMiddleware();
+		this.setupRoutes();
+	}
+	setupMiddleware() {
+		this.app.use(express.json());
+	}
+	setupRoutes() {
+		this.app.get("/sse", async (req, res) => {
+			await this.handleSseConnection(req, res);
+		});
+		this.app.post("/messages", async (req, res) => {
+			await this.handlePostMessage(req, res);
+		});
+		this.app.get("/health", (_req, res) => {
+			res.json({
+				status: "ok",
+				transport: "sse"
+			});
+		});
+	}
+	async handleSseConnection(_req, res) {
+		try {
+			const mcpServer = this.serverFactory();
+			const transport = new SSEServerTransport("/messages", res);
+			this.sessionManager.setSession(transport.sessionId, transport, mcpServer);
+			res.on("close", () => {
+				this.sessionManager.deleteSession(transport.sessionId);
+			});
+			await mcpServer.connect(transport);
+			process.stderr.write(`SSE session established: ${transport.sessionId}\n`);
+		} catch (error) {
+			process.stderr.write(`Error handling SSE connection: ${error instanceof Error ? error.message : String(error)}\n`);
+			if (!res.headersSent) res.status(500).send("Internal Server Error");
+		}
+	}
+	async handlePostMessage(req, res) {
+		const sessionId = req.query.sessionId;
+		if (!sessionId) {
+			res.status(400).send("Missing sessionId query parameter");
+			return;
+		}
+		const transport = this.sessionManager.getSession(sessionId);
+		if (!transport) {
+			res.status(404).send("No transport found for sessionId");
+			return;
+		}
+		try {
+			await transport.handlePostMessage(req, res, req.body);
+		} catch (error) {
+			process.stderr.write(`Error handling post message: ${error instanceof Error ? error.message : String(error)}\n`);
+			if (!res.headersSent) res.status(500).send("Internal Server Error");
+		}
+	}
+	async start() {
+		return new Promise((resolve$1, reject) => {
+			try {
+				this.server = this.app.listen(this.config.port, this.config.host, () => {
+					process.stderr.write(`imagine-mcp MCP server started with SSE transport on http://${this.config.host}:${this.config.port}\n`);
+					process.stderr.write(`SSE endpoint: http://${this.config.host}:${this.config.port}/sse\n`);
+					process.stderr.write(`Messages endpoint: http://${this.config.host}:${this.config.port}/messages\n`);
+					process.stderr.write(`Health check: http://${this.config.host}:${this.config.port}/health\n`);
+					resolve$1();
+				});
+				this.server.on("error", (error) => {
+					reject(error);
+				});
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+	async stop() {
+		return new Promise((resolve$1, reject) => {
+			if (this.server) {
+				this.sessionManager.clear();
+				this.server.close((err) => {
+					if (err) reject(err);
+					else {
+						this.server = null;
+						resolve$1();
+					}
+				});
+			} else resolve$1();
+		});
+	}
+	getPort() {
+		return this.config.port;
+	}
+	getHost() {
+		return this.config.host;
+	}
+};
+
+//#endregion
+//#region src/transports/stdio.ts
+/**
+* Stdio transport handler for MCP server
+* Used for command-line and direct integrations
+*/
+var StdioTransportHandler = class {
+	server;
+	transport = null;
+	constructor(server) {
+		this.server = server;
+	}
+	async start() {
+		this.transport = new StdioServerTransport();
+		await this.server.connect(this.transport);
+		process.stderr.write("imagine-mcp MCP server started on stdio\n");
+	}
+	async stop() {
+		if (this.transport) {
+			await this.transport.close();
+			this.transport = null;
+		}
+	}
+};
+
+//#endregion
+export { UnsplashSearchTool as a, createServer as i, SseTransportHandler as n, ReadImageTool as o, HttpTransportHandler as r, StdioTransportHandler as t };