pi-workspace 0.1.0

package/dist-server/index.mjs

@@ -0,0 +1,763 @@
+import Fastify from "fastify";
+import FastifyVite from "@fastify/vite";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { AuthStorage, ModelRegistry, SessionManager, SettingsManager, createAgentSession, createExtensionRuntime } from "@earendil-works/pi-coding-agent";
+//#region server/chat-validation.ts
+const supportedImageMimeTypes = [
+	"image/png",
+	"image/jpeg",
+	"image/webp",
+	"image/gif"
+];
+function getModelSupportsImages(model) {
+	return Array.isArray(model.input) && model.input.includes("image");
+}
+function getPromptOrDefault(prompt, images) {
+	return prompt?.trim() || (images.length > 0 ? "Please analyze this image." : "");
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStringField$1(value, key) {
+	return isRecord$2(value) && typeof value[key] === "string" ? value[key] : void 0;
+}
+function parseImages(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error("images must be an array");
+	if (value.length > 1) throw new Error(`Only 1 image can be uploaded per message`);
+	return value.map((image) => {
+		if (!isRecord$2(image)) throw new Error("Invalid image attachment");
+		const mimeType = readStringField$1(image, "mimeType");
+		const data = readStringField$1(image, "data");
+		const size = typeof image.size === "number" ? image.size : void 0;
+		if (!mimeType || !supportedImageMimeTypes.includes(mimeType)) throw new Error("Unsupported image type. Upload PNG, JPEG, WebP, or GIF.");
+		if (!data || !/^[A-Za-z0-9+/]+={0,2}$/.test(data)) throw new Error("Invalid image data");
+		const byteLength = Buffer.byteLength(data, "base64");
+		if (byteLength === 0 || byteLength > 5242880) throw new Error("Image must be smaller than 5 MB");
+		if (size && size > 5242880) throw new Error("Image must be smaller than 5 MB");
+		return {
+			type: "image",
+			mimeType,
+			data
+		};
+	});
+}
+//#endregion
+//#region server/pi-sessions.ts
+const MAX_FIRST_MESSAGE_LENGTH = 120;
+const MAX_TOOL_CONTENT_LENGTH = 12e3;
+function truncate(text, maxLength) {
+	if (text.length <= maxLength) return text;
+	return text.slice(0, maxLength) + "…";
+}
+/** Truncate a session first message for display, appending "…" when cut. */
+function truncateFirstMessage(text) {
+	return truncate(text, MAX_FIRST_MESSAGE_LENGTH);
+}
+function extractProjectName(cwd) {
+	if (!cwd) return "(unknown)";
+	const parts = cwd.replace(/\/$/, "").split("/");
+	return parts[parts.length - 1] || "(unknown)";
+}
+function toIsoString(date) {
+	return date.toISOString();
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value, key) {
+	return isRecord$1(value) && typeof value[key] === "string" ? value[key] : void 0;
+}
+function toTimestamp(value, fallback) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	const parsed = Date.parse(fallback);
+	return Number.isFinite(parsed) ? parsed : Date.now();
+}
+function stringifyContent(value) {
+	return truncate(value, MAX_TOOL_CONTENT_LENGTH);
+}
+function isTextContent(value) {
+	return isRecord$1(value) && value.type === "text" && typeof value.text === "string";
+}
+function isImageContent(value) {
+	return isRecord$1(value) && value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string";
+}
+function isThinkingContent(value) {
+	return isRecord$1(value) && value.type === "thinking" && typeof value.thinking === "string";
+}
+function isToolCallContent(value) {
+	return isRecord$1(value) && value.type === "toolCall" && typeof value.id === "string" && typeof value.name === "string";
+}
+function normalizeRichContent(content, entryId) {
+	if (typeof content === "string") return {
+		text: content,
+		images: [],
+		toolCalls: []
+	};
+	if (!Array.isArray(content)) return {
+		text: "",
+		images: [],
+		toolCalls: []
+	};
+	const textParts = [];
+	const images = [];
+	const toolCalls = [];
+	let imageIndex = 0;
+	for (const item of content) {
+		if (isTextContent(item)) {
+			textParts.push(item.text);
+			continue;
+		}
+		if (isImageContent(item)) {
+			imageIndex += 1;
+			images.push({
+				id: `${entryId}-image-${imageIndex - 1}`,
+				data: item.data,
+				mimeType: item.mimeType,
+				name: `Pi session image ${imageIndex}`
+			});
+			continue;
+		}
+		if (isToolCallContent(item)) {
+			toolCalls.push(item);
+			continue;
+		}
+		if (isThinkingContent(item)) continue;
+	}
+	return {
+		text: textParts.join("\n\n").trim(),
+		images,
+		toolCalls
+	};
+}
+function formatToolArguments(argumentsValue) {
+	if (typeof argumentsValue === "string") return stringifyContent(argumentsValue);
+	try {
+		return stringifyContent(JSON.stringify(argumentsValue ?? {}, null, 2));
+	} catch {
+		return "{}";
+	}
+}
+function normalizeContentToText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.filter((item) => isTextContent(item)).map((item) => item.text).join("\n\n").trim();
+}
+function toCustomSummaryTitle(customType) {
+	if (!customType) return "Custom Note";
+	const normalized = customType.replace(/[-_]+/g, " ").trim().replace(/\b\w/g, (match) => match.toUpperCase());
+	return normalized ? `Custom ${normalized}` : "Custom Note";
+}
+function normalizeMessageEntry(entry) {
+	const message = entry.message;
+	if (!message || typeof message.role !== "string") return [];
+	const timestamp = toTimestamp(message.timestamp, entry.timestamp);
+	if (message.role === "user") {
+		const normalized = normalizeRichContent(message.content, entry.id);
+		return [{
+			id: entry.id,
+			role: "user",
+			content: normalized.text,
+			images: normalized.images.length > 0 ? normalized.images : void 0,
+			timestamp
+		}];
+	}
+	if (message.role === "assistant") {
+		const normalized = normalizeRichContent(message.content, entry.id);
+		const result = [];
+		if (normalized.text) result.push({
+			id: entry.id,
+			role: "assistant",
+			content: normalized.text,
+			provider: message.provider,
+			model: message.model,
+			timestamp
+		});
+		for (const toolCall of normalized.toolCalls) result.push({
+			id: `${entry.id}:${toolCall.id}`,
+			role: "tool",
+			toolName: toolCall.name,
+			content: formatToolArguments(toolCall.arguments),
+			isError: false,
+			expandable: true,
+			timestamp
+		});
+		return result;
+	}
+	if (message.role === "toolResult") return [{
+		id: entry.id,
+		role: "tool",
+		toolName: message.toolName || "tool",
+		content: stringifyContent(normalizeContentToText(message.content)),
+		isError: Boolean(message.isError),
+		expandable: true,
+		timestamp
+	}];
+	if (message.role === "bashExecution") {
+		const lines = [`$ ${message.command || ""}`];
+		if (message.output) lines.push(message.output);
+		return [{
+			id: entry.id,
+			role: "tool",
+			toolName: "bash",
+			content: stringifyContent(lines.join("\n").trim()),
+			isError: typeof message.exitCode === "number" ? message.exitCode !== 0 : false,
+			expandable: true,
+			timestamp
+		}];
+	}
+	if (message.role === "custom") {
+		if (!message.display) return [];
+		return [{
+			id: entry.id,
+			role: "summary",
+			summaryType: "custom",
+			title: toCustomSummaryTitle(message.customType),
+			content: normalizeContentToText(message.content) || "",
+			timestamp
+		}];
+	}
+	if (message.role === "branchSummary") return [{
+		id: entry.id,
+		role: "summary",
+		summaryType: "branch",
+		title: "Branch Summary",
+		content: readString(message, "summary") || "",
+		timestamp
+	}];
+	if (message.role === "compactionSummary") return [{
+		id: entry.id,
+		role: "summary",
+		summaryType: "compaction",
+		title: "Compaction Summary",
+		content: readString(message, "summary") || "",
+		timestamp
+	}];
+	return [];
+}
+function normalizeSummaryEntry(entry) {
+	const timestamp = toTimestamp(void 0, entry.timestamp);
+	const summary = entry.summary || "";
+	if (entry.type === "compaction") return [{
+		id: entry.id,
+		role: "summary",
+		summaryType: "compaction",
+		title: "Compaction Summary",
+		content: summary,
+		timestamp
+	}];
+	if (entry.type === "branch_summary") return [{
+		id: entry.id,
+		role: "summary",
+		summaryType: "branch",
+		title: "Branch Summary",
+		content: summary,
+		timestamp
+	}];
+	return [];
+}
+function groupSessionsByProject(rawSessions) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const session of rawSessions) {
+		const key = session.cwd || "";
+		if (!groups.has(key)) groups.set(key, {
+			path: session.cwd,
+			sessions: []
+		});
+		groups.get(key).sessions.push(session);
+	}
+	const projects = [];
+	for (const [cwd, group] of groups) {
+		group.sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+		projects.push({
+			name: extractProjectName(cwd),
+			path: group.path,
+			sessions: group.sessions.map((s) => ({
+				id: s.id,
+				firstMessage: truncateFirstMessage(s.firstMessage),
+				messageCount: s.messageCount,
+				created: toIsoString(s.created),
+				modified: toIsoString(s.modified)
+			}))
+		});
+	}
+	projects.sort((a, b) => a.name.localeCompare(b.name));
+	return projects;
+}
+function findSessionById(rawSessions, sessionId) {
+	return rawSessions.find((session) => session.id === sessionId) || null;
+}
+function normalizeBranchEntries(entries) {
+	return entries.flatMap((entry) => {
+		if (entry.type === "message") return normalizeMessageEntry(entry);
+		return normalizeSummaryEntry(entry);
+	});
+}
+function inferBranchModel(entries) {
+	for (let index = entries.length - 1; index >= 0; index -= 1) {
+		const entry = entries[index];
+		if (entry.type === "model_change" && typeof readString(entry, "provider") === "string" && typeof readString(entry, "modelId") === "string") return {
+			provider: readString(entry, "provider"),
+			modelId: readString(entry, "modelId")
+		};
+		if (entry.type !== "message") continue;
+		const message = entry.message;
+		if (message?.role === "assistant" && typeof message.provider === "string" && typeof message.model === "string") return {
+			provider: message.provider,
+			modelId: message.model
+		};
+	}
+	return null;
+}
+function buildPiSessionDetail(session, entries) {
+	return {
+		session: {
+			id: session.id,
+			name: session.name?.trim() || session.firstMessage.trim() || "Pi session",
+			cwd: session.cwd,
+			projectName: extractProjectName(session.cwd),
+			created: toIsoString(session.created),
+			modified: toIsoString(session.modified)
+		},
+		messages: normalizeBranchEntries(entries)
+	};
+}
+async function loadPiSessionDetailById(sessionId) {
+	const match = findSessionById(await SessionManager.listAll(), sessionId);
+	if (!match) return null;
+	return buildPiSessionDetail(match, SessionManager.open(match.path).getBranch());
+}
+async function loadPiSessionContextById(sessionId) {
+	const match = findSessionById(await SessionManager.listAll(), sessionId);
+	if (!match) return null;
+	const sessionManager = SessionManager.open(match.path);
+	const entries = sessionManager.getBranch();
+	return {
+		session: match,
+		sessionManager,
+		entries,
+		model: inferBranchModel(entries)
+	};
+}
+//#endregion
+//#region server/index.ts
+const commandCodeProviderBaseUrl = process.env.COMMANDCODE_API_BASE || "https://api.commandcode.ai/provider";
+const commandCodeModelsUrl = process.env.COMMANDCODE_MODELS_URL || "https://api.commandcode.ai/provider/v1/models";
+const commandCodeOpenAiBaseUrl = `${commandCodeProviderBaseUrl.replace(/\/$/, "")}/v1`;
+const commandCodeAnthropicBaseUrl = commandCodeProviderBaseUrl.replace(/\/$/, "");
+const commandCodeDefaultMaxTokens = 65536;
+const port = Number(process.env.PORT || 8787);
+const sessions = /* @__PURE__ */ new Map();
+const piSessions = /* @__PURE__ */ new Map();
+function sendEvent(res, event) {
+	res.write(`data: ${JSON.stringify(event)}\n\n`);
+}
+function buildResourceLoader(systemPrompt) {
+	return {
+		getExtensions: () => ({
+			extensions: [],
+			errors: [],
+			runtime: createExtensionRuntime()
+		}),
+		getSkills: () => ({
+			skills: [],
+			diagnostics: []
+		}),
+		getPrompts: () => ({
+			prompts: [],
+			diagnostics: []
+		}),
+		getThemes: () => ({
+			themes: [],
+			diagnostics: []
+		}),
+		getAgentsFiles: () => ({ agentsFiles: [] }),
+		getSystemPrompt: () => systemPrompt,
+		getAppendSystemPrompt: () => [],
+		extendResources: () => {},
+		reload: async () => {}
+	};
+}
+function configureRuntimeAuth(authStorage) {
+	const commandCodeApiKey = readCommandCodeApiKey();
+	if (commandCodeApiKey) authStorage.setRuntimeApiKey("commandcode", commandCodeApiKey);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStringField(value, key) {
+	return isRecord(value) && typeof value[key] === "string" ? value[key] : void 0;
+}
+function readCommandCodeCredential(value) {
+	if (!isRecord(value)) return void 0;
+	if (value.type === "api") return readStringField(value, "key");
+	if (value.type === "oauth") return readStringField(value, "access");
+	return readStringField(value, "key") || readStringField(value, "access");
+}
+function readCommandCodeApiKey() {
+	const authPaths = [path.join(homedir(), ".commandcode", "auth.json"), path.join(homedir(), ".pi", "agent", "auth.json")];
+	for (const authPath of authPaths) try {
+		if (!existsSync(authPath)) continue;
+		const parsed = JSON.parse(readFileSync(authPath, "utf-8"));
+		if (!isRecord(parsed)) continue;
+		const apiKey = readStringField(parsed, "apiKey") || readStringField(parsed, "commandcode") || readCommandCodeCredential(parsed.commandcode) || readCommandCodeCredential(parsed["command-code"]);
+		if (apiKey) return apiKey;
+	} catch {}
+}
+function getMissingAuthMessage(provider) {
+	if (provider === "commandcode") return "Missing local Command Code auth. Sign in with Command Code CLI or add ~/.commandcode/auth.json.";
+	return `Missing local ${provider} auth. Sign in with Pi CLI or add credentials to ~/.pi/agent/auth.json.`;
+}
+function parseCommandCodeModels(value) {
+	if (!isRecord(value) || value.object !== "list" || !Array.isArray(value.data)) throw new Error("Unexpected Command Code model list response.");
+	return value.data.filter((model) => {
+		if (!isRecord(model)) return false;
+		return typeof model.id === "string" && typeof model.name === "string" && typeof model.context_length === "number";
+	}).map((model) => {
+		const isClaude = model.id.toLowerCase().startsWith("claude");
+		return {
+			id: model.id,
+			name: `${model.name} (Command Code)`,
+			api: isClaude ? "anthropic-messages" : "openai-completions",
+			baseUrl: isClaude ? commandCodeAnthropicBaseUrl : commandCodeOpenAiBaseUrl,
+			reasoning: true,
+			input: ["text"],
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0
+			},
+			contextWindow: model.context_length,
+			maxTokens: Math.min(model.context_length, commandCodeDefaultMaxTokens),
+			compat: isClaude ? void 0 : {
+				supportsDeveloperRole: false,
+				supportsReasoningEffort: false,
+				maxTokensField: "max_tokens"
+			}
+		};
+	});
+}
+async function registerCommandCodeProvider(authStorage, modelRegistry) {
+	if (!authStorage.hasAuth("commandcode")) return;
+	const response = await fetch(commandCodeModelsUrl, { headers: { accept: "application/json" } });
+	if (!response.ok) throw new Error(`Failed to fetch Command Code models: ${response.status} ${response.statusText}`);
+	const models = parseCommandCodeModels(await response.json());
+	modelRegistry.registerProvider("commandcode", {
+		name: "Command Code",
+		baseUrl: commandCodeOpenAiBaseUrl,
+		apiKey: "local-commandcode-auth",
+		authHeader: true,
+		api: "openai-completions",
+		headers: { "x-cli-environment": "production" },
+		models
+	});
+}
+async function createLocalModelRegistry() {
+	const authStorage = AuthStorage.create();
+	configureRuntimeAuth(authStorage);
+	const modelRegistry = ModelRegistry.create(authStorage);
+	await registerCommandCodeProvider(authStorage, modelRegistry);
+	return {
+		authStorage,
+		modelRegistry
+	};
+}
+async function getOrCreateSession(sessionId, provider, modelId, systemPrompt) {
+	const existing = sessions.get(sessionId);
+	if (existing && existing.provider === provider && existing.model === modelId && existing.systemPrompt === systemPrompt) return existing.session;
+	existing?.session.dispose();
+	const { authStorage, modelRegistry } = await createLocalModelRegistry();
+	const model = modelRegistry.find(provider, modelId);
+	if (!model) throw new Error(`Unknown model: ${provider}/${modelId}`);
+	if (!modelRegistry.hasConfiguredAuth(model)) throw new Error(getMissingAuthMessage(provider));
+	const { session } = await createAgentSession({
+		cwd: process.cwd(),
+		agentDir: path.join(process.cwd(), ".my-pi-agent"),
+		authStorage,
+		modelRegistry,
+		model,
+		thinkingLevel: "off",
+		noTools: "all",
+		resourceLoader: buildResourceLoader(systemPrompt),
+		sessionManager: SessionManager.inMemory(process.cwd()),
+		settingsManager: SettingsManager.inMemory({
+			compaction: { enabled: false },
+			retry: {
+				enabled: true,
+				maxRetries: 1
+			}
+		})
+	});
+	sessions.set(sessionId, {
+		session,
+		provider,
+		model: modelId,
+		systemPrompt
+	});
+	return session;
+}
+async function createPersistedPiSession(piSessionId, provider, modelId) {
+	const cached = piSessions.get(piSessionId);
+	if (cached) return cached;
+	const context = await loadPiSessionContextById(piSessionId);
+	if (!context) return null;
+	const { authStorage, modelRegistry } = await createLocalModelRegistry();
+	const resolvedProvider = provider || context.model?.provider;
+	const resolvedModelId = modelId || context.model?.modelId;
+	const model = resolvedProvider && resolvedModelId ? modelRegistry.find(resolvedProvider, resolvedModelId) : void 0;
+	if (model && !modelRegistry.hasConfiguredAuth(model)) throw new Error(getMissingAuthMessage(model.provider));
+	const { session } = await createAgentSession({
+		cwd: context.session.cwd,
+		authStorage,
+		modelRegistry,
+		model,
+		thinkingLevel: "off",
+		sessionManager: context.sessionManager,
+		settingsManager: SettingsManager.inMemory({
+			compaction: { enabled: false },
+			retry: {
+				enabled: true,
+				maxRetries: 1
+			}
+		})
+	});
+	const record = {
+		session,
+		provider: model?.provider || resolvedProvider || "unknown",
+		modelId: model?.id || resolvedModelId || "unknown"
+	};
+	piSessions.set(piSessionId, record);
+	return record;
+}
+async function buildServer() {
+	const server = Fastify({ bodyLimit: 8 * 1024 * 1024 });
+	await server.register(FastifyVite, {
+		root: path.resolve(import.meta.dirname, ".."),
+		dev: process.argv.includes("--dev"),
+		spa: true
+	});
+	server.get("/api/health", async (_request, _reply) => {
+		return { ok: true };
+	});
+	server.post("/api/pi-sessions", async (request, reply) => {
+		const { cwd } = request.body;
+		if (!cwd?.trim()) {
+			reply.code(400);
+			return { error: "cwd is required" };
+		}
+		try {
+			SessionManager.create(cwd.trim())._rewriteFile();
+			return { projects: groupSessionsByProject(await SessionManager.listAll()) };
+		} catch (error) {
+			reply.code(500);
+			return { error: error instanceof Error ? error.message : "Failed to create Pi session" };
+		}
+	});
+	server.get("/api/pi-sessions", async (_request, reply) => {
+		try {
+			return { projects: groupSessionsByProject(await SessionManager.listAll()) };
+		} catch (error) {
+			reply.code(500);
+			return { error: error instanceof Error ? error.message : "Failed to list Pi sessions" };
+		}
+	});
+	server.get("/api/pi-sessions/:sessionId", async (request, reply) => {
+		const { sessionId } = request.params;
+		if (!sessionId?.trim()) {
+			reply.code(400);
+			return { error: "sessionId is required" };
+		}
+		try {
+			const detail = await loadPiSessionDetailById(sessionId);
+			if (!detail) {
+				reply.code(404);
+				return { error: "Pi session not found" };
+			}
+			return detail;
+		} catch (error) {
+			reply.code(500);
+			return { error: error instanceof Error ? error.message : "Failed to load Pi session" };
+		}
+	});
+	server.get("/api/models", async (_request, reply) => {
+		try {
+			const { modelRegistry } = await createLocalModelRegistry();
+			return { models: modelRegistry.getAvailable().map((model) => ({
+				provider: model.provider,
+				model: model.id,
+				label: `${model.name || model.id} (${model.provider})`,
+				supportsImages: getModelSupportsImages(model)
+			})) };
+		} catch (error) {
+			reply.code(500);
+			return { error: error instanceof Error ? error.message : "Failed to load models" };
+		}
+	});
+	server.post("/api/chat", async (request, reply) => {
+		const body = request.body;
+		const requestedProvider = body.provider;
+		const requestedModelId = body.model;
+		let images;
+		try {
+			images = parseImages(body.images);
+		} catch (error) {
+			reply.code(400);
+			return { error: error instanceof Error ? error.message : "Invalid image attachment" };
+		}
+		const prompt = getPromptOrDefault(body.prompt, images);
+		const sessionId = request.headers["x-session-id"] || "default";
+		const piSessionId = request.headers["x-pi-session-id"];
+		const systemPrompt = body.systemPrompt?.trim() || "You are My Pi, a concise online agent assistant. Ask clarifying questions when requirements are incomplete.";
+		if (!prompt) {
+			reply.code(400);
+			return { error: "prompt is required" };
+		}
+		if (images.length > 0) try {
+			if (piSessionId) {
+				const persistedSession = await createPersistedPiSession(piSessionId, requestedProvider, requestedModelId);
+				persistedSession?.session.dispose();
+				if (!persistedSession) {
+					reply.code(404);
+					return { error: "Pi session not found" };
+				}
+				if (persistedSession.provider !== "unknown" && persistedSession.modelId !== "unknown") {
+					const { modelRegistry } = await createLocalModelRegistry();
+					const model = modelRegistry.find(persistedSession.provider, persistedSession.modelId);
+					if (!model || !getModelSupportsImages(model)) {
+						reply.code(400);
+						return { error: `Model ${persistedSession.provider}/${persistedSession.modelId} does not support image input` };
+					}
+				}
+			} else {
+				const provider = requestedProvider || "openai";
+				const modelId = requestedModelId || "gpt-4o-mini";
+				const { modelRegistry } = await createLocalModelRegistry();
+				const model = modelRegistry.find(provider, modelId);
+				if (!model || !getModelSupportsImages(model)) {
+					reply.code(400);
+					return { error: `Model ${provider}/${modelId} does not support image input` };
+				}
+			}
+		} catch (error) {
+			reply.code(500);
+			return { error: error instanceof Error ? error.message : "Failed to validate image model support" };
+		}
+		reply.hijack();
+		const raw = reply.raw;
+		raw.writeHead(200, {
+			"Content-Type": "text/event-stream; charset=utf-8",
+			"Cache-Control": "no-cache, no-transform",
+			Connection: "keep-alive"
+		});
+		try {
+			const persistedSession = piSessionId ? await createPersistedPiSession(piSessionId, requestedProvider, requestedModelId) : null;
+			if (piSessionId && !persistedSession) {
+				sendEvent(raw, {
+					type: "error",
+					error: "Pi session not found"
+				});
+				return;
+			}
+			const provider = persistedSession?.provider || requestedProvider || "openai";
+			const modelId = persistedSession?.modelId || requestedModelId || "gpt-4o-mini";
+			const session = persistedSession?.session || await getOrCreateSession(sessionId, provider, modelId, systemPrompt);
+			let finalText = "";
+			const unsubscribe = session.subscribe((event) => {
+				if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+					finalText += event.assistantMessageEvent.delta;
+					sendEvent(raw, {
+						type: "delta",
+						delta: event.assistantMessageEvent.delta
+					});
+				}
+				if (event.type === "message_update" && event.assistantMessageEvent.type === "thinking_delta") sendEvent(raw, {
+					type: "thinking",
+					delta: event.assistantMessageEvent.delta
+				});
+				if (event.type === "tool_execution_start") sendEvent(raw, {
+					type: "tool_start",
+					toolName: event.toolName,
+					toolCallId: event.toolCallId,
+					args: typeof event.args === "string" ? event.args : JSON.stringify(event.args ?? {})
+				});
+				if (event.type === "tool_execution_update") sendEvent(raw, {
+					type: "tool_delta",
+					toolName: event.toolName,
+					toolCallId: event.toolCallId,
+					delta: typeof event.partialResult === "string" ? event.partialResult : JSON.stringify(event.partialResult ?? "")
+				});
+				if (event.type === "tool_execution_end") sendEvent(raw, {
+					type: "tool_end",
+					toolName: event.toolName,
+					toolCallId: event.toolCallId,
+					content: typeof event.result === "string" ? event.result : JSON.stringify(event.result ?? ""),
+					isError: event.isError
+				});
+				if (event.type === "agent_end") sendEvent(raw, {
+					type: "done",
+					message: {
+						role: "assistant",
+						content: finalText,
+						provider,
+						model: modelId,
+						timestamp: Date.now()
+					}
+				});
+			});
+			try {
+				await session.prompt(prompt, images.length > 0 ? { images } : void 0);
+			} finally {
+				unsubscribe();
+				if (!piSessionId) persistedSession?.session.dispose();
+			}
+		} catch (error) {
+			sendEvent(raw, {
+				type: "error",
+				error: error instanceof Error ? error.message : "Unexpected server error"
+			});
+		} finally {
+			raw.end();
+		}
+	});
+	server.setNotFoundHandler((_request, reply) => {
+		return reply.html();
+	});
+	await server.vite.ready();
+	return server;
+}
+async function startWithRetry(fastify, retries) {
+	for (let attempt = 1; attempt <= retries; attempt++) try {
+		const address = await new Promise((resolve, reject) => {
+			fastify.listen({
+				port,
+				host: "127.0.0.1"
+			}, (err, addr) => {
+				if (err) reject(err);
+				else resolve(addr);
+			});
+		});
+		console.log(`My Pi server listening on ${address}`);
+		return;
+	} catch (error) {
+		if (error instanceof Error && error.code === "EADDRINUSE" && attempt < retries) {
+			console.log(`Port ${port} is in use, retrying in 1s (attempt ${attempt}/${retries - 1})…`);
+			await new Promise((r) => setTimeout(r, 1e3));
+		} else {
+			console.error("Failed to start server:", error);
+			process.exit(1);
+		}
+	}
+}
+const server = await buildServer();
+process.on("SIGTERM", async () => {
+	try {
+		await server.close();
+	} catch {}
+	process.exit(0);
+});
+await startWithRetry(server, 5);
+//#endregion
+export {};