@od-oneapp/ai-platform 0.1.0

package/dist/server.mjs

@@ -0,0 +1,2225 @@
+import { Nt as streamText, Z as generateId, p as UI_MESSAGE_STREAM_HEADERS, w as createAgentUIStreamResponse } from "./ai-runtime-CDzQztTt.mjs";
+import { i as normalizeError, n as formatErrorMessage, r as getErrorCode, t as formatConnectionError } from "./errors-Dtn-UeRi.mjs";
+import { r as verifySignature, t as generateSignature } from "./crypto-8ABhc3TD.mjs";
+import { i as wrapWithCompliance, r as preprocessMessages } from "./compliance-wrapper-CrOMHhHN.mjs";
+import { t as createResumableStream } from "./resumable-adapter-CO1HtsgJ.mjs";
+import { t as createLogNotifier } from "./log-adapter-PPe_2Pwv.mjs";
+import { z } from "zod";
+import { logError, logInfo, logWarn } from "@od-oneapp/shared/logs";
+import { createAIConversationOrm, createAIMessageOrm, findAIConversationOrm, updateAIConversationOrm } from "@od-oneapp/db-prisma/orm";
+import { AIMessageRole, AISessionType } from "@od-oneapp/db-prisma/types";
+
+//#region src/server/routes/health-check.ts
+/**
+* Check database connectivity
+*/
+async function checkDatabase(config, timeoutMs) {
+	if (config.enableDatabase === false) return {
+		connected: true,
+		status: "up"
+	};
+	const databaseUrl = config.databaseUrl || process.env.DATABASE_URL || process.env.POSTGRES_URL;
+	if (!databaseUrl) return {
+		connected: false,
+		status: "down",
+		error: "DATABASE_URL not configured"
+	};
+	try {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), timeoutMs);
+		const startTime = Date.now();
+		try {
+			const postgresModule = await import("postgres");
+			const postgresDefault = postgresModule && typeof postgresModule === "object" && "default" in postgresModule ? postgresModule.default : void 0;
+			if (typeof postgresDefault !== "function") throw new Error("postgres module is unavailable");
+			const client = postgresDefault(databaseUrl, {
+				prepare: false,
+				max: 1,
+				idle_timeout: 3
+			});
+			await Promise.race([client`SELECT 1`, new Promise((resolve, reject) => {
+				setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout")), timeoutMs);
+			})]);
+			await client.end();
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			throw new Error(`Database connection failed: ${errorMessage}`);
+		}
+		const latency = Date.now() - startTime;
+		clearTimeout(timeout);
+		return {
+			connected: true,
+			status: "up",
+			latency
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		return {
+			connected: false,
+			status: "down",
+			error: config.includeSensitiveDetails ? errorMessage : "Connection failed"
+		};
+	}
+}
+/**
+* Check Redis connectivity
+*/
+async function checkRedis(config, timeoutMs) {
+	if (config.enableRedis === false) return {
+		connected: true,
+		status: "up"
+	};
+	const redisUrl = config.redisUrl || process.env.REDIS_URL;
+	if (!redisUrl) return {
+		connected: true,
+		status: "up"
+	};
+	try {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), timeoutMs);
+		const startTime = Date.now();
+		try {
+			const redisModule = await import("redis");
+			const createClient = redisModule && typeof redisModule === "object" && "createClient" in redisModule ? redisModule.createClient : void 0;
+			if (typeof createClient !== "function") throw new Error("redis module is unavailable");
+			const redisClient = createClient({
+				url: redisUrl,
+				socket: { reconnectStrategy: () => false }
+			});
+			await Promise.race([redisClient.connect().then(() => redisClient.ping()), new Promise((resolve, reject) => {
+				setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout")), timeoutMs);
+			})]);
+			await redisClient.close();
+		} catch {
+			const response = await Promise.race([fetch(redisUrl, { signal: controller.signal }), new Promise((resolve, reject) => {
+				setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout")), timeoutMs);
+			})]);
+			if (!response || response.status >= 400) throw new Error("Redis connection failed");
+		}
+		const latency = Date.now() - startTime;
+		clearTimeout(timeout);
+		return {
+			connected: true,
+			status: "up",
+			latency
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		return {
+			connected: false,
+			status: "down",
+			error: config.includeSensitiveDetails ? errorMessage : "Connection failed"
+		};
+	}
+}
+/**
+* Check AI provider availability
+*/
+async function checkAIProvider(config, timeoutMs) {
+	if (config.enableAIProvider === false) return {
+		available: true,
+		status: "up"
+	};
+	try {
+		const startTime = Date.now();
+		const providers = {
+			openai: true,
+			anthropic: true,
+			gemini: true
+		};
+		if (config.enableAIProviderTest) try {
+			const { generateText } = await import("ai");
+			const { openai } = await import("@ai-sdk/openai");
+			const controller = new AbortController();
+			const timeout = setTimeout(() => controller.abort(), timeoutMs);
+			try {
+				await Promise.race([generateText({
+					model: openai("gpt-4o-mini"),
+					prompt: "health",
+					maxOutputTokens: 1,
+					abortSignal: controller.signal
+				}).catch(() => {
+					return null;
+				}), new Promise((resolve, reject) => {
+					setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout")), timeoutMs);
+				})]);
+			} finally {
+				clearTimeout(timeout);
+			}
+		} catch {}
+		return {
+			available: true,
+			status: "up",
+			providers,
+			latency: Date.now() - startTime
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		return {
+			available: false,
+			status: "down",
+			error: config.includeSensitiveDetails ? errorMessage : "Provider check failed"
+		};
+	}
+}
+/**
+* Check system memory usage
+*/
+function checkMemory(config) {
+	if (config.enableMemory === false) return {
+		heapUsed: 0,
+		heapTotal: 0,
+		external: 0,
+		rss: 0,
+		heapUsedPercent: 0,
+		status: "ok"
+	};
+	const memUsage = process.memoryUsage();
+	const heapUsedPercent = memUsage.heapUsed / memUsage.heapTotal * 100;
+	const warningThreshold = config.memoryWarningThreshold ?? 80;
+	const criticalThreshold = config.memoryCriticalThreshold ?? 90;
+	let status = "ok";
+	if (heapUsedPercent >= criticalThreshold) status = "critical";
+	else if (heapUsedPercent >= warningThreshold) status = "warning";
+	return {
+		heapUsed: Math.round(memUsage.heapUsed),
+		heapTotal: Math.round(memUsage.heapTotal),
+		external: Math.round(memUsage.external),
+		rss: Math.round(memUsage.rss),
+		heapUsedPercent: Math.round(heapUsedPercent * 100) / 100,
+		status
+	};
+}
+/**
+* Determine overall service status based on component health
+*/
+function determineStatus(database, redis, aiProvider, memory) {
+	if (database && !database.connected) return "unhealthy";
+	if (redis && !redis.connected || aiProvider && !aiProvider.available) return "degraded";
+	if (memory?.status === "critical") return "degraded";
+	return "healthy";
+}
+/**
+* Execute custom health checks
+*/
+async function executeCustomChecks(customChecks, timeoutMs) {
+	const results = {};
+	for (const customCheck of customChecks) try {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), timeoutMs);
+		const result = await Promise.race([customCheck.check(), new Promise((resolve, reject) => {
+			setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout")), timeoutMs);
+		})]);
+		results[customCheck.name] = normalizeCustomCheckResult(result);
+		clearTimeout(timeout);
+	} catch (error) {
+		results[customCheck.name] = {
+			status: "down",
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+	return results;
+}
+function normalizeCustomCheckResult(value) {
+	if (typeof value === "object" && value !== null) return value;
+	return {
+		status: "down",
+		error: "Custom check returned invalid result"
+	};
+}
+/**
+* Main health check function
+* Performs comprehensive health checks on all configured dependencies
+*
+* @param config - Health check configuration
+* @returns Promise<HealthCheckResult> - Comprehensive health check result
+*/
+async function checkHealth(config) {
+	const startTime = Date.now();
+	const timeoutMs = config.checkTimeoutMs ?? 2e3;
+	const version = config.version ?? process.env.npm_package_version ?? "1.0.0";
+	const environment = process.env.NODE_ENV ?? "development";
+	const [database, redis, aiProvider, memory] = await Promise.all([
+		config.enableDatabase !== false ? checkDatabase(config, timeoutMs) : Promise.resolve(void 0),
+		config.enableRedis !== false ? checkRedis(config, timeoutMs) : Promise.resolve(void 0),
+		config.enableAIProvider !== false ? checkAIProvider(config, timeoutMs) : Promise.resolve(void 0),
+		config.enableMemory !== false ? checkMemory(config) : Promise.resolve(void 0)
+	]);
+	let customChecksResults = {};
+	if (config.customChecks && config.customChecks.length > 0) customChecksResults = await executeCustomChecks(config.customChecks, timeoutMs);
+	const checks = {};
+	if (database !== void 0) checks.database = database;
+	if (redis !== void 0) checks.redis = redis;
+	if (aiProvider !== void 0) checks.aiProvider = aiProvider;
+	if (memory !== void 0) checks.memory = memory;
+	Object.assign(checks, customChecksResults);
+	const status = determineStatus(database, redis, aiProvider, memory);
+	const responseTime = Date.now() - startTime;
+	return {
+		status,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		version,
+		environment,
+		uptime: process.uptime(),
+		responseTime,
+		checks
+	};
+}
+/**
+* Create a health check request handler
+* Returns a function compatible with Express, Next.js, or other Node.js frameworks
+*
+* @param config - Health check configuration
+* @returns RequestHandler function
+*
+* @example
+* // Express
+* app.get('/health', createHealthCheckHandler({ enableDatabase: true }));
+*
+* // Next.js Route Handler
+* export const GET = createHealthCheckHandler({ enableDatabase: true });
+*/
+function createHealthCheckHandler(config) {
+	return async (req, res) => {
+		try {
+			const result = await checkHealth(config);
+			const statusCode = result.status === "unhealthy" ? 503 : 200;
+			res.setHeader("Content-Type", "application/json");
+			res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+			res.status(statusCode).json(result);
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			res.setHeader("Content-Type", "application/json");
+			res.status(503).json({
+				status: "unhealthy",
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				error: config.includeSensitiveDetails ? errorMessage : "Health check failed",
+				version: config.version ?? process.env.npm_package_version ?? "1.0.0",
+				environment: process.env.NODE_ENV ?? "development"
+			});
+		}
+	};
+}
+/**
+* Create a health check handler for Next.js 13+ Route Handlers
+* Returns NextResponse compatible handler
+*
+* @param config - Health check configuration
+* @returns Handler function for Next.js Route Handlers
+*
+* @example
+* // app/api/health/route.ts
+* export const GET = createNextHealthCheckHandler({ enableDatabase: true });
+*/
+function createNextHealthCheckHandler(config) {
+	const handler = async () => {
+		try {
+			const result = await checkHealth(config);
+			const statusCode = result.status === "unhealthy" ? 503 : 200;
+			return new Response(JSON.stringify(result), {
+				status: statusCode,
+				headers: { "Content-Type": "application/json" }
+			});
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			return new Response(JSON.stringify({
+				status: "unhealthy",
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				error: config.includeSensitiveDetails ? errorMessage : "Health check failed",
+				version: config.version ?? process.env.npm_package_version ?? "1.0.0",
+				environment: process.env.NODE_ENV ?? "development"
+			}), {
+				status: 503,
+				headers: { "Content-Type": "application/json" }
+			});
+		}
+	};
+	return handler;
+}
+/**
+* Express middleware factory for health check endpoint
+*
+* @param config - Health check configuration
+* @returns Express middleware function
+*
+* @example
+* import express from 'express';
+* import { createHealthCheckMiddleware } from './health-check';
+*
+* const app = express();
+* app.use(createHealthCheckMiddleware({ enableDatabase: true }));
+*/
+function createHealthCheckMiddleware(config) {
+	let cachedResult = null;
+	let cacheTime = 0;
+	const cacheDuration = config.cacheDurationMs ?? 0;
+	return async (req, res, next) => {
+		if (!req.path?.endsWith("/health") && !req.url?.endsWith("/health")) return next?.();
+		try {
+			if (cachedResult && cacheDuration > 0) {
+				if (Date.now() - cacheTime < cacheDuration) {
+					const statusCode = cachedResult.status === "unhealthy" ? 503 : 200;
+					return res.status(statusCode).json(cachedResult);
+				}
+			}
+			const result = await checkHealth(config);
+			if (cacheDuration > 0) {
+				cachedResult = result;
+				cacheTime = Date.now();
+			}
+			const statusCode = result.status === "unhealthy" ? 503 : 200;
+			res.setHeader("Content-Type", "application/json");
+			res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+			res.status(statusCode).json(result);
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			res.setHeader("Content-Type", "application/json");
+			res.status(503).json({
+				status: "unhealthy",
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				error: config.includeSensitiveDetails ? errorMessage : "Health check failed",
+				version: config.version ?? process.env.npm_package_version ?? "1.0.0",
+				environment: process.env.NODE_ENV ?? "development"
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/server/messages/extraction.ts
+/**
+* @fileoverview Message extraction and session utilities migrated from @od-oneapp/ai.
+*
+* Provides functions for extracting content from UI messages, validating messages,
+* session initialization, and message persistence helpers.
+*
+* @module @od-oneapp/ai-platform/server/messages/extraction
+*/
+/**
+* Extract text content from a UIMessage by joining all text parts.
+*
+* @param message - UI message to extract text from
+* @returns Concatenated text from all text parts, or empty string
+*
+* @example
+* ```ts
+* const text = extractTextContent(message);
+* ```
+*/
+function extractTextContent(message) {
+	if (!message.parts) return "";
+	return message.parts.filter((part) => {
+		return part.type === "text" && "text" in part;
+	}).map((part) => part.text).join("\n");
+}
+/**
+* Extract file attachments from a UIMessage.
+*
+* @param message - UI message to extract files from
+* @returns Array of extracted file parts
+*
+* @example
+* ```ts
+* const files = extractFileAttachments(message);
+* ```
+*/
+function extractFileAttachments(message) {
+	if (!message.parts) return [];
+	return message.parts.filter((part) => {
+		return part.type === "file" && "name" in part && "url" in part && "mimeType" in part;
+	});
+}
+/**
+* Find the last user message in an array of messages.
+*
+* @param messages - Array of UIMessage objects
+* @returns The last user message or null if none found
+*
+* @example
+* ```ts
+* const lastUser = getLastUserMessage(messages);
+* if (lastUser) {
+*   console.log(extractTextContent(lastUser));
+* }
+* ```
+*/
+function getLastUserMessage(messages) {
+	return messages.findLast((message) => message.role === "user") ?? null;
+}
+/**
+* Basic message validator for UIMessage arrays.
+*
+* @param messages - Unknown value to validate
+* @returns Type guard confirming the value is a UIMessage array
+*/
+function defaultValidateMessages(messages) {
+	return Array.isArray(messages);
+}
+/**
+* Extract text from a UIMessage that may contain parts or plain content.
+*
+* @param message - UI message to extract text from
+* @returns Plain text string from the message
+*/
+function defaultGetMessageText(message) {
+	if ("content" in message && typeof message.content === "string") return message.content;
+	if ("parts" in message && Array.isArray(message.parts)) return message.parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+	return "";
+}
+/**
+* Minimal default session initializer using in-memory IDs.
+* Consumers can override with database-backed implementations.
+*/
+const inMemoryInitializeSession = async (sessionId) => ({
+	sessionId: sessionId ?? generateId(),
+	isNew: !sessionId
+});
+/** No-op persistence helper for environments without storage. */
+const noopPersistMessage = async () => {};
+/** No-op resumable stream helper for environments without resumption support. */
+const noopSetupResumableStream = async () => {};
+/**
+* Extract reasoning text from a finish event.
+* Handles both array and string formats for reasoning.
+*
+* @param finishEvent - Finish event from streamText/generateText
+* @returns Reasoning text string or undefined
+*
+* @example
+* ```ts
+* const reasoning = extractReasoningText(event);
+* if (reasoning) {
+*   console.log('Model reasoning:', reasoning);
+* }
+* ```
+*/
+function extractReasoningText(finishEvent) {
+	if (!finishEvent.reasoning) return void 0;
+	if (Array.isArray(finishEvent.reasoning)) return finishEvent.reasoning.map((r) => r?.text ?? "").join("");
+	if (typeof finishEvent.reasoning === "string") return finishEvent.reasoning;
+}
+/**
+* Build UI message parts from AI SDK finish event.
+* Extracts text, reasoning, tool calls, and tool results from the finish event.
+*
+* @param finishEvent - Finish event from streamText/generateText
+* @returns Array of UI message parts
+*/
+function buildUIMessagePartsFromFinishEvent(finishEvent) {
+	const parts = [];
+	if (finishEvent.text) parts.push({
+		type: "text",
+		text: finishEvent.text
+	});
+	if (finishEvent.reasoning && Array.isArray(finishEvent.reasoning)) {
+		const reasoningText = finishEvent.reasoning.map((r) => r?.text ?? "").join("");
+		if (reasoningText) parts.push({
+			type: "reasoning",
+			text: reasoningText
+		});
+	} else if (finishEvent.reasoning && typeof finishEvent.reasoning === "string") parts.push({
+		type: "reasoning",
+		text: finishEvent.reasoning
+	});
+	if (finishEvent.toolCalls && finishEvent.toolCalls.length > 0) for (const tc of finishEvent.toolCalls) {
+		const args = "args" in tc ? tc.args : tc.input;
+		parts.push({
+			type: "tool-invocation",
+			toolCallId: tc.toolCallId,
+			toolName: tc.toolName,
+			args: args ?? {}
+		});
+	}
+	if (finishEvent.toolResults && finishEvent.toolResults.length > 0) for (const tr of finishEvent.toolResults) {
+		const result = "result" in tr ? tr.result : tr.output;
+		parts.push({
+			type: "tool-result",
+			toolCallId: tr.toolCallId,
+			toolName: tr.toolName,
+			result: result ?? null
+		});
+	}
+	return parts;
+}
+/**
+* Map stored message to UI message format.
+* Converts database-stored message format to AI SDK UIMessage format.
+*
+* @param stored - Stored message from database
+* @returns UIMessage compatible with AI SDK
+*/
+function mapStoredToUIMessage(stored) {
+	return {
+		id: stored.id,
+		role: stored.role,
+		parts: Array.isArray(stored.parts) && stored.parts.length > 0 ? stored.parts : stored.content ? [{
+			type: "text",
+			text: stored.content
+		}] : []
+	};
+}
+/**
+* Map array of stored messages to UI messages format.
+*
+* @param stored - Array of stored messages from database
+* @returns Array of UIMessage compatible with AI SDK
+*/
+function mapStoredMessagesToUI(stored) {
+	return stored.map(mapStoredToUIMessage);
+}
+
+//#endregion
+//#region src/server/routes/agent-routes.ts
+/**
+* @fileoverview Agent route handler factory for Next.js/Fetch-compatible routes.
+*
+* Creates POST handlers that handle request parsing, session initialization,
+* user message persistence, agent execution, and optional stream resumption.
+*
+* Migrated from @od-oneapp/ai/server/agent-routes.ts
+*
+* @module @od-oneapp/ai-platform/server/routes/agent-routes
+*/
+/**
+* Create a JSON error response.
+* Consistent error format for agent route handlers.
+*/
+function jsonError$1(error, status = 400) {
+	return new Response(JSON.stringify({ error }), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+/**
+* Create a Next.js/Fetch-compatible POST handler for AI SDK agents.
+*
+* Handles request parsing, session initialization, user message persistence,
+* agent execution, and optional stream resumption.
+*
+* @param options - Route handler configuration
+* @returns POST handler function
+*
+* @example
+* ```ts
+* import { createAgentRouteHandler } from '@od-oneapp/ai-platform/server';
+*
+* const POST = createAgentRouteHandler({
+*   agent: myToolLoopAgent,
+*   sendReasoning: true,
+*   initializeSession: myDbSessionInit,
+*   persistUserMessage: myDbPersist,
+* });
+*
+* export { POST };
+* ```
+*/
+function createAgentRouteHandler(options) {
+	const { agent, execute, sendReasoning = true, onError, resolveOptions, initializeSession = inMemoryInitializeSession, persistUserMessage, setupResumableStream, validateMessages = defaultValidateMessages, getMessageText = defaultGetMessageText } = options;
+	return async function POST(req) {
+		const body = await req.json().catch(() => null);
+		if (!body || typeof body !== "object") return jsonError$1("Invalid request body", 400);
+		const { messages, id, ...rest } = body;
+		if (!validateMessages(messages)) return jsonError$1("Invalid request: messages must be an array", 400);
+		const uiMessages = messages;
+		const { sessionId, isNew } = await initializeSession(id);
+		if (persistUserMessage && uiMessages.length > 0) {
+			const lastUser = typeof uiMessages.findLast === "function" ? uiMessages.findLast((m) => m.role === "user") : [...uiMessages].reverse().find((m) => m.role === "user");
+			if (lastUser) {
+				const text = getMessageText(lastUser);
+				if (text) await persistUserMessage(sessionId, text, { autoTitle: isNew });
+			}
+		}
+		let response;
+		if (execute) {
+			const bodyObj = {
+				messages: uiMessages,
+				...rest
+			};
+			if (id !== void 0) bodyObj.id = id;
+			response = await execute({
+				messages: uiMessages,
+				sessionId,
+				isNew,
+				body: bodyObj
+			});
+		} else if (agent) response = await createAgentUIStreamResponse({
+			agent,
+			uiMessages,
+			sendReasoning,
+			options: resolveOptions?.({
+				body: {
+					messages: uiMessages,
+					id,
+					...rest
+				},
+				messages: uiMessages,
+				sessionId
+			}),
+			onError: onError ? (error) => {
+				return onError(error, { sessionId }) ?? "An error occurred";
+			} : void 0
+		});
+		else return jsonError$1("No agent or execute handler provided", 500);
+		if (setupResumableStream) await setupResumableStream(response, sessionId);
+		return response;
+	};
+}
+
+//#endregion
+//#region src/server/messages/converter.ts
+/**
+* Default configuration for message converter.
+*/
+const DEFAULT_CONFIG$1 = {
+	stripSystemMessages: false,
+	maxMessages: Infinity,
+	transform: void 0
+};
+/**
+* Creates a message converter for transforming UI messages to model format.
+*
+* The converter applies the following transformations in order:
+* 1. Custom transform function (if provided)
+* 2. System message filtering (if stripSystemMessages is true)
+* 3. Sliding window truncation (if maxMessages is set)
+* 4. Conversion to model message format
+*
+* @param config - Converter configuration options.
+* @returns MessageConverter instance.
+*
+* @example Basic usage
+* ```ts
+* const converter = createMessageConverter();
+* const modelMessages = await converter.toModelMessages(uiMessages);
+* ```
+*
+* @example With configuration
+* ```ts
+* const converter = createMessageConverter({
+*   maxMessages: 20,
+*   stripSystemMessages: true,
+* });
+*
+* // Only last 20 non-system messages will be included
+* const modelMessages = await converter.toModelMessages(uiMessages);
+* ```
+*
+* @example With custom transform
+* ```ts
+* const converter = createMessageConverter({
+*   transform: (msg) => {
+*     // Filter out empty messages
+*     if (!msg.content.trim()) return null;
+*     // Normalize content
+*     return { ...msg, content: msg.content.toLowerCase() };
+*   },
+* });
+* ```
+*/
+function createMessageConverter(config = {}) {
+	const mergedConfig = {
+		...DEFAULT_CONFIG$1,
+		...config
+	};
+	/**
+	* Applies all transformations to the message array.
+	* @param messages - Input messages.
+	* @returns Transformed messages.
+	*/
+	function processMessages(messages) {
+		let processed = [...messages];
+		if (mergedConfig.transform) {
+			const { transform } = mergedConfig;
+			processed = processed.map((msg) => transform(msg)).filter((msg) => msg !== null);
+		}
+		if (mergedConfig.stripSystemMessages) processed = processed.filter((msg) => msg.role !== "system");
+		if (mergedConfig.maxMessages < Infinity && processed.length > mergedConfig.maxMessages) processed = processed.slice(-mergedConfig.maxMessages);
+		return processed;
+	}
+	/**
+	* Converts a single UI message to model message format.
+	* @param uiMessage - UI message to convert.
+	* @returns Model message.
+	*/
+	function convertToModelMessage(uiMessage) {
+		return {
+			role: uiMessage.role,
+			content: uiMessage.content
+		};
+	}
+	return {
+		async toModelMessages(messages) {
+			return processMessages(messages).map(convertToModelMessage);
+		},
+		toModelMessagesSync(messages) {
+			return processMessages(messages).map(convertToModelMessage);
+		}
+	};
+}
+/**
+* Creates a transform function that chains multiple transforms.
+*
+* @param transforms - Array of transform functions to chain.
+* @returns Combined transform function.
+*
+* @example
+* ```ts
+* const converter = createMessageConverter({
+*   transform: chainTransforms([
+*     // Remove empty messages
+*     (msg) => msg.content.trim() ? msg : null,
+*     // Normalize whitespace
+*     (msg) => ({ ...msg, content: msg.content.replace(/\s+/g, ' ') }),
+*   ]),
+* });
+* ```
+*/
+function chainTransforms(transforms) {
+	return (msg) => {
+		let current = msg;
+		for (const transform of transforms) {
+			if (current === null) return null;
+			current = transform(current);
+		}
+		return current;
+	};
+}
+/**
+* Creates a transform that filters messages by role.
+*
+* @param allowedRoles - Roles to allow through.
+* @returns Transform function.
+*
+* @example
+* ```ts
+* const converter = createMessageConverter({
+*   transform: filterByRole(['user', 'assistant']),
+* });
+* ```
+*/
+function filterByRole(allowedRoles) {
+	const roleSet = new Set(allowedRoles);
+	return (msg) => roleSet.has(msg.role) ? msg : null;
+}
+/**
+* Creates a transform that filters messages by content.
+*
+* @param predicate - Function to test message content.
+* @returns Transform function.
+*
+* @example
+* ```ts
+* // Filter out messages with only whitespace
+* const converter = createMessageConverter({
+*   transform: filterByContent((content) => content.trim().length > 0),
+* });
+* ```
+*/
+function filterByContent(predicate) {
+	return (msg) => predicate(msg.content) ? msg : null;
+}
+/**
+* Creates a transform that modifies message content.
+*
+* @param modifier - Function to modify content.
+* @returns Transform function.
+*
+* @example
+* ```ts
+* // Trim all message content
+* const converter = createMessageConverter({
+*   transform: transformContent((content) => content.trim()),
+* });
+* ```
+*/
+function transformContent(modifier) {
+	return (msg) => ({
+		...msg,
+		content: modifier(msg.content)
+	});
+}
+
+//#endregion
+//#region src/server/messages/data-parts.ts
+/**
+* @fileoverview Data part extractor factory for type-safe data extraction.
+* @module @od-oneapp/ai-platform/messages
+*
+* Provides factory for creating typed data part extractors that validate
+* and extract custom data from message streams.
+*
+* @example
+* ```ts
+* import { z } from 'zod';
+* import { createDataPartExtractor } from '@od-oneapp/ai-platform/messages';
+*
+* const ToolShimmerSchema = z.object({
+*   toolCallId: z.string(),
+*   toolName: z.string(),
+*   state: z.enum(['pending', 'loading', 'success', 'error']),
+* });
+*
+* const ProgressSchema = z.object({
+*   current: z.number(),
+*   total: z.number(),
+* });
+*
+* const extractor = createDataPartExtractor({
+*   schemas: {
+*     'tool-shimmer': ToolShimmerSchema,
+*     'progress': ProgressSchema,
+*   },
+*   onUnknownType: (type, data) => {
+*     console.warn(`Unknown data part type: ${type}`);
+*   },
+* });
+*
+* const shimmers = extractor.extract(messages, 'tool-shimmer');
+* const allParts = extractor.extractAll(messages);
+* ```
+*/
+/**
+* Creates a type-safe data part extractor with Zod schema validation.
+*
+* The extractor validates each data part against its registered schema,
+* providing type-safe access to custom streaming data.
+*
+* @param config - Extractor configuration with schema map.
+* @returns DataPartExtractor instance.
+*
+* @example Basic usage
+* ```ts
+* import { z } from 'zod';
+*
+* const SourceSchema = z.object({
+*   id: z.string(),
+*   url: z.string().url(),
+*   title: z.string(),
+* });
+*
+* const extractor = createDataPartExtractor({
+*   schemas: { source: SourceSchema },
+* });
+*
+* // Type-safe extraction - returns Source[]
+* const sources = extractor.extract(messages, 'source');
+* ```
+*
+* @example With unknown type handler
+* ```ts
+* const extractor = createDataPartExtractor({
+*   schemas: { progress: ProgressSchema },
+*   onUnknownType: (type, data) => {
+*     // Log unknown types for debugging
+*     console.warn(`Unhandled data part: ${type}`, data);
+*   },
+* });
+* ```
+*
+* @example Extracting all types
+* ```ts
+* const allParts = extractor.extractAll(messages);
+* // { progress: [...], source: [...] }
+* ```
+*/
+function createDataPartExtractor(config) {
+	const { schemas, onUnknownType } = config;
+	const schemaKeys = new Set(Object.keys(schemas));
+	/**
+	* Extracts data parts from a single message.
+	* @param message - Message to extract from.
+	* @returns Array of data parts.
+	*/
+	function extractFromMessage(message) {
+		const parts = [];
+		if (message.data && Array.isArray(message.data)) parts.push(...message.data);
+		if (message.parts && Array.isArray(message.parts)) {
+			for (const part of message.parts) if (part && typeof part === "object" && "type" in part && "data" in part && typeof part.type === "string") parts.push(part);
+		}
+		return parts;
+	}
+	/**
+	* Validates a data part against its schema.
+	* @param type - Type of the data part.
+	* @param data - Data to validate.
+	* @returns Validated data or null if invalid.
+	*/
+	function validateDataPart(type, data) {
+		const schema = schemas[type];
+		if (!schema) return null;
+		const result = schema.safeParse(data);
+		if (result.success) return result.data;
+		if (process.env.NODE_ENV === "development") logWarn(`Data part validation failed for type "${type}"`, { error: result.error });
+		return null;
+	}
+	return {
+		extract(messages, type) {
+			const results = [];
+			for (const message of messages) {
+				const parts = extractFromMessage(message);
+				for (const part of parts) if (part.type === type) {
+					const validated = validateDataPart(type, part.data);
+					if (validated !== null) results.push(validated);
+				} else if (!schemaKeys.has(part.type) && onUnknownType) onUnknownType(part.type, part.data);
+			}
+			return results;
+		},
+		extractAll(messages) {
+			const results = {};
+			for (const type of schemaKeys) results[type] = [];
+			for (const message of messages) {
+				const parts = extractFromMessage(message);
+				for (const part of parts) if (schemaKeys.has(part.type)) {
+					const type = part.type;
+					const validated = validateDataPart(type, part.data);
+					if (validated !== null) results[type]?.push(validated);
+				} else if (onUnknownType) onUnknownType(part.type, part.data);
+			}
+			return results;
+		},
+		hasSchema(type) {
+			return schemaKeys.has(type);
+		}
+	};
+}
+/**
+* Creates a combined extractor from multiple schema maps.
+*
+* @param extractors - Array of extractor configs to combine.
+* @returns Combined DataPartExtractorConfig.
+*
+* @example
+* ```ts
+* const combinedSchemas = mergeSchemas(
+*   { progress: ProgressSchema },
+*   { source: SourceSchema, step: StepSchema },
+* );
+*
+* const extractor = createDataPartExtractor({
+*   schemas: combinedSchemas,
+* });
+* ```
+*/
+function mergeSchemas(schemas1, schemas2) {
+	return {
+		...schemas1,
+		...schemas2
+	};
+}
+/**
+* Collects all data parts from messages without validation.
+*
+* @param messages - Messages to collect from.
+* @returns Array of all data parts.
+*
+* @example
+* ```ts
+* const allParts = collectDataParts(messages);
+* // [{ type: 'progress', data: {...} }, { type: 'source', data: {...} }]
+* ```
+*/
+function collectDataParts(messages) {
+	const parts = [];
+	for (const message of messages) {
+		if (message.data && Array.isArray(message.data)) parts.push(...message.data);
+		if (message.parts && Array.isArray(message.parts)) {
+			for (const part of message.parts) if (part && typeof part === "object" && "type" in part && "data" in part && typeof part.type === "string") parts.push(part);
+		}
+	}
+	return parts;
+}
+/**
+* Groups data parts by type.
+*
+* @param parts - Data parts to group.
+* @returns Object with data parts grouped by type.
+*
+* @example
+* ```ts
+* const grouped = groupDataPartsByType(parts);
+* // { 'progress': [...], 'source': [...] }
+* ```
+*/
+function groupDataPartsByType(parts) {
+	const grouped = {};
+	for (const part of parts) {
+		const bucket = grouped[part.type] ?? [];
+		bucket.push(part);
+		grouped[part.type] = bucket;
+	}
+	return grouped;
+}
+/**
+* Gets the latest data part of a specific type.
+*
+* @param messages - Messages to search.
+* @param type - Type of data part to find.
+* @returns Latest data part of the type or undefined.
+*
+* @example
+* ```ts
+* const latestProgress = getLatestDataPart(messages, 'progress');
+* ```
+*/
+function getLatestDataPart(messages, type) {
+	const parts = collectDataParts(messages);
+	for (let i = parts.length - 1; i >= 0; i--) {
+		const part = parts[i];
+		if (part?.type === type) return part;
+	}
+}
+
+//#endregion
+//#region src/server/messages/window.ts
+/**
+* @fileoverview Message window factory for token-based message truncation.
+* @module @od-oneapp/ai-platform/messages
+*
+* Provides factory for creating message windows that manage conversation
+* history within token limits.
+*
+* @example
+* ```ts
+* import { createMessageWindow } from '@od-oneapp/ai-platform/messages';
+*
+* const window = createMessageWindow({
+*   maxTokens: 8000,
+*   preserveSystemMessage: true,
+*   strategy: 'fifo',
+* });
+*
+* const truncated = await window.apply(messages);
+* const tokens = window.estimateTokens(messages);
+* ```
+*/
+/**
+* Default configuration for message window.
+*/
+const DEFAULT_CONFIG = {
+	maxTokens: 4096,
+	tokenizer: "cl100k_base",
+	preserveSystemMessage: true,
+	strategy: "fifo",
+	summarizer: void 0
+};
+/**
+* Estimates tokens per character for different tokenizers.
+* These are approximations based on typical encoding ratios.
+*/
+const CHARS_PER_TOKEN = {
+	cl100k_base: 4,
+	p50k_base: 4,
+	default: 4
+};
+/**
+* Creates a tokenizer function from a tokenizer type.
+*
+* @param tokenizer - Tokenizer type or custom function.
+* @returns Tokenizer function.
+*/
+function createTokenizer(tokenizer) {
+	if (typeof tokenizer === "function") return tokenizer;
+	const charsPerToken = CHARS_PER_TOKEN[tokenizer] ?? CHARS_PER_TOKEN.default ?? 4;
+	return (text) => {
+		return Math.ceil(text.length / charsPerToken) + 4;
+	};
+}
+/**
+* Simple word-based tokenizer for rough estimates.
+* Counts words and adds overhead.
+*
+* @param text - Text to estimate tokens for.
+* @returns Estimated token count.
+*/
+function wordBasedTokenizer(text) {
+	const words = text.split(/\s+/).filter((w) => w.length > 0);
+	return Math.ceil(words.length * 1.3) + 4;
+}
+/**
+* Creates a message window for managing conversation history within token limits.
+*
+* The window applies truncation strategies to keep messages within the
+* configured token budget while optionally preserving system messages.
+*
+* @param config - Window configuration options.
+* @returns MessageWindow instance.
+*
+* @example Basic FIFO truncation
+* ```ts
+* const window = createMessageWindow({
+*   maxTokens: 4000,
+* });
+*
+* const truncated = await window.apply(messages);
+* // Oldest messages removed to fit within 4000 tokens
+* ```
+*
+* @example Preserve system message
+* ```ts
+* const window = createMessageWindow({
+*   maxTokens: 8000,
+*   preserveSystemMessage: true,
+* });
+*
+* // System message always included, other messages truncated as needed
+* const truncated = await window.apply(messages);
+* ```
+*
+* @example Custom tokenizer
+* ```ts
+* import { encodingForModel } from 'js-tiktoken';
+*
+* const encoding = encodingForModel('gpt-4');
+*
+* const window = createMessageWindow({
+*   maxTokens: 8000,
+*   tokenizer: (text) => encoding.encode(text).length,
+* });
+* ```
+*
+* @example Summarize strategy
+* ```ts
+* const window = createMessageWindow({
+*   maxTokens: 8000,
+*   strategy: 'summarize',
+*   summarizer: async (messages) => {
+*     // Use LLM to summarize older messages
+*     const summary = await generateSummary(messages);
+*     return { role: 'system', content: `Previous context: ${summary}` };
+*   },
+* });
+* ```
+*/
+function createMessageWindow(config) {
+	const mergedConfig = {
+		...DEFAULT_CONFIG,
+		...config
+	};
+	const tokenize = createTokenizer(mergedConfig.tokenizer);
+	/**
+	* Estimates tokens for a single message.
+	* @param message - Message to estimate.
+	* @returns Estimated token count.
+	*/
+	function estimateMessageTokens(message) {
+		let { content } = message;
+		if (message.parts) {
+			for (const part of message.parts) if ("text" in part && typeof part.text === "string") content += ` ${part.text}`;
+		}
+		return tokenize(content);
+	}
+	/**
+	* Estimates total tokens for an array of messages.
+	* @param messages - Messages to estimate.
+	* @returns Total estimated token count.
+	*/
+	function estimateTokens(messages) {
+		let total = 0;
+		for (const message of messages) total += estimateMessageTokens(message);
+		return total;
+	}
+	/**
+	* Applies FIFO truncation strategy.
+	* Removes oldest messages first, optionally preserving system message.
+	* @param messages - Messages to truncate.
+	* @returns Truncated messages.
+	*/
+	function applyFIFO(messages) {
+		if (messages.length === 0) return messages;
+		let systemMessage;
+		let nonSystemMessages;
+		if (mergedConfig.preserveSystemMessage) {
+			systemMessage = messages.find((m) => m.role === "system");
+			nonSystemMessages = messages.filter((m) => m.role !== "system");
+		} else nonSystemMessages = [...messages];
+		const systemTokens = systemMessage ? estimateMessageTokens(systemMessage) : 0;
+		const availableTokens = mergedConfig.maxTokens - systemTokens;
+		if (availableTokens <= 0 && systemMessage) return [systemMessage];
+		const result = [];
+		let currentTokens = 0;
+		for (let i = nonSystemMessages.length - 1; i >= 0; i--) {
+			const message = nonSystemMessages[i];
+			if (!message) continue;
+			const messageTokens = estimateMessageTokens(message);
+			if (currentTokens + messageTokens <= availableTokens) {
+				result.unshift(message);
+				currentTokens += messageTokens;
+			} else break;
+		}
+		if (systemMessage) result.unshift(systemMessage);
+		return result;
+	}
+	/**
+	* Applies summarize truncation strategy.
+	* Summarizes older messages when they would be truncated.
+	* @param messages - Messages to process.
+	* @returns Processed messages with summaries.
+	*/
+	async function applySummarize(messages) {
+		if (!mergedConfig.summarizer) return applyFIFO(messages);
+		if (estimateTokens(messages) <= mergedConfig.maxTokens) return messages;
+		let systemMessage;
+		let nonSystemMessages;
+		if (mergedConfig.preserveSystemMessage) {
+			systemMessage = messages.find((m) => m.role === "system");
+			nonSystemMessages = messages.filter((m) => m.role !== "system");
+		} else nonSystemMessages = [...messages];
+		const systemTokens = systemMessage ? estimateMessageTokens(systemMessage) : 0;
+		const targetTokens = mergedConfig.maxTokens - systemTokens;
+		const toKeep = [];
+		let keepTokens = 0;
+		let splitIndex = nonSystemMessages.length;
+		for (let i = nonSystemMessages.length - 1; i >= 0; i--) {
+			const message = nonSystemMessages[i];
+			if (!message) continue;
+			const messageTokens = estimateMessageTokens(message);
+			const reserveForSummary = Math.floor(targetTokens * .25);
+			if (keepTokens + messageTokens <= targetTokens - reserveForSummary) {
+				toKeep.unshift(message);
+				keepTokens += messageTokens;
+				splitIndex = i;
+			} else break;
+		}
+		if (splitIndex === 0) return systemMessage ? [systemMessage, ...toKeep] : toKeep;
+		const toSummarize = nonSystemMessages.slice(0, splitIndex);
+		const summaryMessage = await mergedConfig.summarizer(toSummarize);
+		const result = [];
+		if (systemMessage) result.push(systemMessage);
+		result.push(summaryMessage);
+		result.push(...toKeep);
+		return result;
+	}
+	return {
+		async apply(messages) {
+			if (messages.length === 0) return messages;
+			if (estimateTokens(messages) <= mergedConfig.maxTokens) return messages;
+			if (mergedConfig.strategy === "summarize") return applySummarize(messages);
+			return applyFIFO(messages);
+		},
+		applySync(messages) {
+			if (messages.length === 0) return messages;
+			if (estimateTokens(messages) <= mergedConfig.maxTokens) return messages;
+			if (mergedConfig.strategy === "summarize") logWarn("applySync does not support summarize strategy, falling back to FIFO");
+			return applyFIFO(messages);
+		},
+		estimateTokens,
+		estimateMessageTokens
+	};
+}
+/**
+* Creates a compact window for short context models (4K tokens).
+*
+* @returns MessageWindow with 4K token limit.
+*
+* @example
+* ```ts
+* const window = createCompactWindow();
+* const truncated = await window.apply(messages);
+* ```
+*/
+function createCompactWindow() {
+	return createMessageWindow({
+		maxTokens: 4096,
+		preserveSystemMessage: true,
+		strategy: "fifo"
+	});
+}
+/**
+* Creates a standard window for medium context models (8K tokens).
+*
+* @returns MessageWindow with 8K token limit.
+*
+* @example
+* ```ts
+* const window = createStandardWindow();
+* const truncated = await window.apply(messages);
+* ```
+*/
+function createStandardWindow() {
+	return createMessageWindow({
+		maxTokens: 8192,
+		preserveSystemMessage: true,
+		strategy: "fifo"
+	});
+}
+/**
+* Creates a large window for long context models (32K tokens).
+*
+* @returns MessageWindow with 32K token limit.
+*
+* @example
+* ```ts
+* const window = createLargeWindow();
+* const truncated = await window.apply(messages);
+* ```
+*/
+function createLargeWindow() {
+	return createMessageWindow({
+		maxTokens: 32768,
+		preserveSystemMessage: true,
+		strategy: "fifo"
+	});
+}
+/**
+* Creates an extended window for very long context models (128K tokens).
+*
+* @returns MessageWindow with 128K token limit.
+*
+* @example
+* ```ts
+* const window = createExtendedWindow();
+* const truncated = await window.apply(messages);
+* ```
+*/
+function createExtendedWindow() {
+	return createMessageWindow({
+		maxTokens: 131072,
+		preserveSystemMessage: true,
+		strategy: "fifo"
+	});
+}
+
+//#endregion
+//#region src/server/helpers.ts
+/**
+* @fileoverview api-helpers.ts
+*/
+/**
+* API Route Helpers
+* DRY utilities for Next.js API routes with database persistence
+*/
+const defaultWaitUntil = (promise) => {};
+const defaultTokenTtlSeconds = () => {
+	const raw = process.env.STREAM_RESUME_TOKEN_TTL_SEC ?? "3600";
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : 3600;
+};
+const getResumptionSigningKey = () => process.env.STREAM_RESUME_SIGNING_KEY ?? process.env.AUDIT_SIGNING_KEY;
+const encodeBase64Url = (value) => {
+	if (typeof Buffer !== "undefined") return Buffer.from(value, "utf8").toString("base64url");
+	if (typeof btoa !== "undefined") return btoa(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+	throw new Error("Base64 encoding unavailable");
+};
+const decodeBase64Url = (value) => {
+	if (typeof Buffer !== "undefined") return Buffer.from(value, "base64url").toString("utf8");
+	if (typeof atob !== "undefined") {
+		const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+		const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+		return atob(padded);
+	}
+	throw new Error("Base64 decoding unavailable");
+};
+const createResumptionToken = async (payload) => {
+	const signingKey = getResumptionSigningKey();
+	if (!signingKey) throw new Error("STREAM_RESUME_SIGNING_KEY or AUDIT_SIGNING_KEY is required for resumption");
+	const encodedPayload = encodeBase64Url(JSON.stringify(payload));
+	return `${encodedPayload}.${await generateSignature({ payload: encodedPayload }, signingKey)}`;
+};
+const verifyResumptionToken = async (token) => {
+	const signingKey = getResumptionSigningKey();
+	if (!signingKey) throw new Error("STREAM_RESUME_SIGNING_KEY or AUDIT_SIGNING_KEY is required for resumption");
+	const parts = token.split(".");
+	if (parts.length !== 2) return null;
+	const encodedPayload = parts[0];
+	const signature = parts[1];
+	if (!encodedPayload || !signature) return null;
+	if (!await verifySignature({ payload: encodedPayload }, signature, signingKey)) return null;
+	const payload = JSON.parse(decodeBase64Url(encodedPayload));
+	if (!payload || typeof payload !== "object") return null;
+	if (Date.now() > payload.expiresAt) return null;
+	return payload;
+};
+const resolveStreamResumptionOptions = (options) => {
+	if (typeof options === "function") return { waitUntil: options };
+	return options ?? {};
+};
+const resolveSetupResumableStreamOptions = (options) => {
+	if (typeof options === "function") return { waitUntil: options };
+	return options ?? {};
+};
+const isRecord = (value) => {
+	return typeof value === "object" && value !== null;
+};
+const normalizeError$1 = (error) => {
+	if (error instanceof Error) return { message: error.message };
+	if (typeof error === "string") return { message: error };
+	if (isRecord(error) && typeof error.message === "string") return { message: error.message };
+	return { message: "Unknown error" };
+};
+const toByteStream = (stream) => {
+	const encoder = new TextEncoder();
+	return stream.pipeThrough(new TransformStream({ transform(chunk, controller) {
+		if (typeof chunk === "string") {
+			controller.enqueue(encoder.encode(chunk));
+			return;
+		}
+		if (chunk instanceof Uint8Array) {
+			controller.enqueue(chunk);
+			return;
+		}
+		controller.enqueue(encoder.encode(String(chunk)));
+	} }));
+};
+/**
+* Extracts error message from unknown error type.
+* Provides consistent error message extraction across all routes.
+*
+* @param {unknown} error - The error to extract message from
+* @returns {string} The error message
+*
+* @example
+* ```ts
+* // Extract error message
+* const message = getErrorMessage(error);
+* return jsonError(message, 500);
+* ```
+*/
+const getErrorMessage = (error) => {
+	return normalizeError$1(error).message;
+};
+/**
+* Creates a JSON error response with consistent format.
+*
+* @param {string | Error} error - The error message or Error object
+* @param {number} [status] - HTTP status code
+* @returns {Response} JSON error response
+*
+* @example
+* ```ts
+* // Create error response
+* return jsonError('Invalid request', 400);
+* // or
+* return jsonError(error, 500);
+* ```
+*/
+const jsonError = (error, status = 500) => {
+	const message = typeof error === "string" ? error : error.message;
+	return new Response(JSON.stringify({ error: message }), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+};
+/**
+* Creates a JSON success response.
+*
+* @template T
+* @param {T} data - The data to return
+* @param {number} [status] - HTTP status code
+* @returns {Response} JSON success response
+*
+* @example
+* ```ts
+* // Create success response
+* return jsonSuccess({ userId: '123', name: 'John' }, 200);
+* ```
+*/
+const jsonSuccess = (data, status = 200) => {
+	return new Response(JSON.stringify(data), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+};
+/**
+* Parses and validates request body.
+* Returns typed data or error response.
+*
+* @template T
+* @param {Request} req - The request object
+* @returns {Promise<{ data: T } | { error: Response }>} Parsed data or error response
+*
+* @example
+* ```ts
+* // Parse request body
+* const result = await parseRequestBody<{ message: string }>(req);
+* if ('error' in result) {
+*   return result.error;
+* }
+* const { message } = result.data;
+* ```
+*/
+const parseRequestBody = async (req) => {
+	try {
+		return { data: await req.json() };
+	} catch {
+		return { error: jsonError("Invalid JSON in request body", 400) };
+	}
+};
+/**
+* Validates that messages is a non-empty array of UIMessage.
+*
+* @param {unknown} messages - The value to validate
+* @returns {messages is UIMessage[]} True if messages is a valid array
+*
+* @example
+* ```ts
+* // Validate messages
+* if (!validateMessages(messages)) {
+*   return jsonError('Invalid messages format', 400);
+* }
+* ```
+*/
+const validateMessages = (messages) => {
+	return Array.isArray(messages) && messages.length > 0;
+};
+/**
+* Common response options for streaming
+*/
+const STREAM_RESPONSE_OPTIONS = {
+	standard: {
+		sendSources: true,
+		sendReasoning: true
+	},
+	sources: { sendSources: true },
+	minimal: {}
+};
+/**
+* Creates experimental_telemetry config for AI SDK v6.
+* Provides observability for AI operations.
+*
+* @param {object} options - Telemetry configuration options
+* @param {string} options.functionId - Unique identifier for the function
+* @param {string} options.component - Component name
+* @param {string} [options.version] - Version string
+* @param {Record<string, unknown>} [options.metadata] - Additional metadata
+* @returns {object} Telemetry configuration object
+*
+* @example
+* ```ts
+* // Create telemetry config
+* const telemetry = createTelemetryConfig({
+*   functionId: 'chat-handler',
+*   component: 'chat-api',
+*   version: '1.0.0',
+*   metadata: { userId: '123' }
+* });
+* ```
+*/
+const createTelemetryConfig = (options) => {
+	return {
+		isEnabled: true,
+		functionId: options.functionId,
+		metadata: {
+			component: options.component,
+			version: options.version || "1.0.0",
+			...options.metadata
+		}
+	};
+};
+/**
+* Handle stream resumption for GET /stream routes
+* Queries the database for activeStreamId and resumes if found.
+*
+* Note: Requires Redis to be configured for resumable streams.
+*/
+async function handleStreamResumption(req, options) {
+	const { waitUntil, auth } = resolveStreamResumptionOptions(options);
+	const effectiveWaitUntil = waitUntil ?? defaultWaitUntil;
+	const chatId = req.headers.get("X-Chat-ID");
+	if (!chatId) return jsonError("Missing X-Chat-ID header", 400);
+	if (!auth) return jsonError("Unauthorized", 401);
+	const userContext = await auth.getUserContext(req);
+	if (!userContext) return jsonError("Unauthorized", 401);
+	if (auth.verifyOwnership) {
+		if (!await auth.verifyOwnership(userContext.userId, chatId)) return jsonError("Forbidden", 403);
+	}
+	const resumptionToken = (await findAIConversationOrm({ id: chatId }))?.activeStreamId;
+	if (!resumptionToken) return new Response(null, { status: 204 });
+	try {
+		const payload = await verifyResumptionToken(resumptionToken);
+		if (payload?.chatId !== chatId || payload.userId !== userContext.userId) {
+			await updateAIConversationOrm({ id: chatId }, { activeStreamId: null }).catch(() => {});
+			return new Response(null, { status: 204 });
+		}
+		const stream = await createResumableStream({ waitUntil: effectiveWaitUntil }).resumeExistingStream(payload.streamId);
+		if (!stream) {
+			await updateAIConversationOrm({ id: chatId }, { activeStreamId: null }).catch(() => {});
+			return new Response(null, { status: 204 });
+		}
+		const responseStream = toByteStream(stream);
+		return new Response(responseStream, { headers: {
+			...UI_MESSAGE_STREAM_HEADERS,
+			"X-Stream-Resumed": "true"
+		} });
+	} catch (error) {
+		logWarn("[handleStreamResumption] Failed to resume stream:", {
+			error,
+			chatId
+		});
+		return new Response(null, { status: 204 });
+	}
+}
+/**
+* Sets up resumable stream for agent responses.
+* Wraps a response stream with resumption capabilities and stores
+* the stream ID in the database for client-side resume.
+*
+* Note: Fails gracefully if Redis is not available - stream will still work,
+* just without resumption support across page refreshes.
+*
+* @param {Response} response - The response stream to wrap
+* @param {string} chatId - The chat/conversation ID for stream tracking
+* @returns {Promise<void>}
+*
+* @example
+* ```ts
+* // Setup resumable stream
+* const response = streamText(...);
+* await setupResumableStream(response, chatId);
+* return response;
+* ```
+*/
+const setupResumableStream = async (response, chatId, options) => {
+	const { waitUntil, userId, tokenTtlSeconds } = resolveSetupResumableStreamOptions(options);
+	const effectiveWaitUntil = waitUntil ?? defaultWaitUntil;
+	try {
+		const streamId = generateId();
+		const streamContext = createResumableStream({ waitUntil: effectiveWaitUntil });
+		if (response.body) {
+			await streamContext.createNewResumableStream(streamId, () => response.body);
+			if (!userId) {
+				logWarn("[setupResumableStream] Missing userId, resumption disabled", { chatId });
+				return;
+			}
+			const ttlSeconds = tokenTtlSeconds ?? defaultTokenTtlSeconds();
+			const resumptionToken = await createResumptionToken({
+				streamId,
+				chatId,
+				userId,
+				issuedAt: Date.now(),
+				expiresAt: Date.now() + ttlSeconds * 1e3
+			});
+			await updateAIConversationOrm({ id: chatId }, { activeStreamId: resumptionToken });
+		}
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ECONNREFUSED") return;
+		logWarn("[setupResumableStream] Failed to setup resumable stream:", { error });
+	}
+};
+/**
+* Gets or generates a chat ID for non-persistent sessions.
+*
+* Note: For persistent sessions with database storage, use initializePersistentSession instead.
+*
+* @param {string} [id] - Optional existing chat ID
+* @returns {string} The chat ID
+*
+* @example
+* ```ts
+* // Initialize chat session
+* const chatId = initializeChatSession();
+* // or with existing ID
+* const chatId = initializeChatSession('existing-id');
+* ```
+*/
+const initializeChatSession = (id) => {
+	return id ?? generateId();
+};
+/**
+* Initializes a persistent chat session with database storage.
+* Use this instead of initializeChatSession for demos that need persistence.
+*
+* @param {object} [options] - Session initialization options
+* @param {string} [options.sessionId] - Existing session ID
+* @param {string} [options.userId] - User ID for the session
+* @param {string} [options.model] - Model name for the session
+* @param {string} [options.demo] - Demo identifier
+* @returns {Promise<{ sessionId: string; isNew: boolean }>} Session ID and whether it's new
+*
+* @example
+* ```ts
+* // Initialize persistent session
+* const { sessionId, isNew } = await initializePersistentSession({
+*   userId: 'user-123',
+*   model: 'gpt-4'
+* });
+* ```
+*/
+const initializePersistentSession = async (options) => {
+	let session;
+	let isNew = false;
+	if (options?.sessionId) session = await findAIConversationOrm({ id: options.sessionId });
+	if (!session) {
+		session = await createAIConversationOrm({
+			...options?.userId ? { user: { connect: { id: options.userId } } } : {},
+			primaryModel: options?.model,
+			sessionType: AISessionType.CONVERSATION
+		});
+		isNew = true;
+	} else if (session.activeStreamId) await updateAIConversationOrm({ id: session.id }, { activeStreamId: null }).catch(() => {});
+	return {
+		sessionId: session.id,
+		isNew
+	};
+};
+/**
+* Wrapper for initializePersistentSession that matches InitializeSessionFn signature
+* Use this with createAgentRouteHandler for consistent session initialization
+*/
+const initializePersistentSessionFn = async (sessionId) => {
+	logInfo("[initializePersistentSessionFn] Starting with sessionId:", { sessionId });
+	try {
+		const result = await initializePersistentSession({ sessionId });
+		logInfo("[initializePersistentSessionFn] Success:", { result });
+		return result;
+	} catch (error) {
+		logError(error instanceof Error ? error : new Error(String(error)), { message: "[initializePersistentSessionFn] Error:" });
+		throw error;
+	}
+};
+/**
+* Save a user message to the database
+*/
+async function persistUserMessage(sessionId, content, options) {
+	await createAIMessageOrm({
+		conversation: { connect: { id: sessionId } },
+		role: AIMessageRole.USER,
+		content
+	});
+	if (options?.autoTitle) {
+		const title = content.slice(0, 50) + (content.length > 50 ? "..." : "");
+		await updateAIConversationOrm({ id: sessionId }, { title }).catch(() => {});
+	}
+}
+/**
+* Saves an assistant message to the database.
+*
+* @param {string} sessionId - The session ID
+* @param {string} content - The message content
+* @returns {Promise<void>}
+*
+* @example
+* ```ts
+* // Persist assistant message
+* await persistAssistantMessage(sessionId, 'Hello! How can I help you?');
+* ```
+*/
+const persistAssistantMessage = async (sessionId, content) => {
+	await createAIMessageOrm({
+		conversation: { connect: { id: sessionId } },
+		role: AIMessageRole.ASSISTANT,
+		content
+	});
+};
+/**
+* Creates a standard onFinish callback for AI SDK streams.
+* Combines stream cleanup with optional usage logging and persistence.
+*
+* AI SDK v6 native feature - leverages built-in onFinish callback
+* instead of manually handling result.usage Promise.
+*
+* @param {string} chatId - The chat ID for stream tracking
+* @param {object} [options] - Callback options
+* @param {boolean} [options.logUsage] - Whether to log usage statistics
+* @param {string} [options.demo] - Demo identifier for logging
+* @param {Logger} [options.logger] - Logger instance for usage logging
+* @param {string} [options.persistSessionId] - Session ID for database persistence
+* @returns {(event: StreamFinishEvent) => Promise<void>} onFinish callback function
+*
+* @example
+* ```ts
+* // Create onFinish callback
+* const onFinish = createOnFinishCallback(chatId, {
+*   logUsage: true,
+*   demo: 'chat-demo',
+*   persistSessionId: sessionId
+* });
+* ```
+*/
+const createOnFinishCallback = (chatId, options) => {
+	return async (event) => {
+		await updateAIConversationOrm({ id: chatId }, { activeStreamId: null }).catch(() => {});
+		if (options?.persistSessionId && event?.text) await persistAssistantMessage(options.persistSessionId, event.text).catch((err) => {
+			options?.logger?.info?.("Failed to persist assistant message", { error: String(err) });
+		});
+		if (options?.logUsage && options?.logger && event?.usage) options.logger.info(`${options.demo || "stream"} usage`, {
+			...event.usage,
+			totalUsage: event.totalUsage,
+			demo: options.demo
+		});
+	};
+};
+/**
+* Calculate model cost with extended pricing data including Vercel AI Gateway models.
+*
+* Supports provider-prefixed model IDs (e.g., 'openai/gpt-4o', 'anthropic/claude-sonnet-4-5')
+* and includes pricing for newer models and gateway-specific models.
+*
+* @param modelId - Model identifier (e.g., 'openai/gpt-4o', 'anthropic/claude-sonnet-4-5')
+* @param usage - Token usage object
+* @returns Estimated cost in USD
+*
+* @example
+* ```typescript
+* const cost = calculateModelCost('openai/gpt-4o', {
+*   inputTokens: 1000,
+*   outputTokens: 500
+* });
+* // Returns: 0.005 (estimated cost in USD)
+* ```
+*/
+const calculateModelCost = (modelId, usage) => {
+	const MODEL_COSTS = {
+		"openai/gpt-4o": {
+			input: .0025,
+			output: .01
+		},
+		"openai/gpt-4o-mini": {
+			input: 15e-5,
+			output: 6e-4
+		},
+		"openai/gpt-5.1-instant": {
+			input: 1e-4,
+			output: 4e-4
+		},
+		"anthropic/claude-sonnet-4-20250514": {
+			input: .003,
+			output: .015
+		},
+		"anthropic/claude-opus-4-5-20251101": {
+			input: .015,
+			output: .075
+		},
+		"perplexity/sonar": {
+			input: .001,
+			output: .001
+		},
+		"gpt-4o": {
+			input: .0025,
+			output: .01
+		},
+		"gpt-4o-mini": {
+			input: 15e-5,
+			output: 6e-4
+		},
+		"gpt-5.1-instant": {
+			input: 1e-4,
+			output: 4e-4
+		},
+		"claude-sonnet-4": {
+			input: .003,
+			output: .015
+		},
+		"claude-opus-4": {
+			input: .015,
+			output: .075
+		},
+		default: {
+			input: .001,
+			output: .002
+		}
+	};
+	const pricing = MODEL_COSTS[modelId] ?? MODEL_COSTS.default ?? {
+		input: .001,
+		output: .002
+	};
+	const inputTokens = usage.inputTokens ?? 0;
+	const outputTokens = usage.outputTokens ?? 0;
+	return inputTokens / 1e3 * pricing.input + outputTokens / 1e3 * pricing.output;
+};
+/**
+* Estimate input tokens from text.
+*
+* Uses rough approximation: ~4 characters per token for English text.
+* This is a simple heuristic and may vary by language and content type.
+*
+* @param text - Text to estimate tokens for
+* @returns Estimated number of input tokens
+*
+* @example
+* ```typescript
+* estimateInputTokens('Hello world'); // Returns: 3 (12 chars / 4)
+* ```
+*/
+const estimateInputTokens = (text) => Math.ceil(text.length / 4);
+/**
+* Extract model name from provider-prefixed model ID.
+*
+* Removes provider prefix from model IDs like "openai/gpt-4o" or "anthropic/claude-3-5-sonnet".
+* Handles both "provider/model" and "provider:model" formats.
+*
+* @param modelId - Model identifier (e.g., "openai/gpt-4o", "openai:gpt-4o", "gpt-4o")
+* @returns Model name without provider prefix
+*
+* @example
+* ```typescript
+* extractModelName('openai/gpt-4o'); // Returns: 'gpt-4o'
+* extractModelName('openai:gpt-4o'); // Returns: 'gpt-4o'
+* extractModelName('gpt-4o'); // Returns: 'gpt-4o'
+* ```
+*/
+const extractModelName = (modelId) => {
+	if (modelId.includes("/")) {
+		const parts = modelId.split("/");
+		return parts[parts.length - 1] ?? modelId;
+	}
+	if (modelId.includes(":")) {
+		const parts = modelId.split(":");
+		return parts[parts.length - 1] ?? modelId;
+	}
+	return modelId;
+};
+/**
+* Round cost to specified decimal places.
+*
+* @param cost - Cost value to round
+* @param decimals - Number of decimal places (default: 6)
+* @returns Rounded cost value
+*
+* @example
+* ```typescript
+* roundCost(0.123456789); // Returns: 0.123457
+* roundCost(0.123456789, 2); // Returns: 0.12
+* ```
+*/
+const roundCost = (cost, decimals = 6) => Math.round(cost * Math.pow(10, decimals)) / Math.pow(10, decimals);
+/**
+* Truncate text to specified length with ellipsis.
+*
+* @param text - Text to truncate
+* @param maxLength - Maximum length before truncation
+* @param ellipsis - Ellipsis string (default: '...')
+* @returns Truncated text
+*
+* @example
+* ```typescript
+* truncateText('Hello world', 8); // Returns: 'Hello...'
+* truncateText('Short', 10); // Returns: 'Short'
+* ```
+*/
+const truncateText = (text, maxLength, ellipsis = "...") => {
+	if (text.length <= maxLength) return text;
+	return `${text.slice(0, maxLength - ellipsis.length)}${ellipsis}`;
+};
+/**
+* Calculate elapsed duration in milliseconds from a start timestamp.
+*
+* @param startTime - Epoch milliseconds captured at the start of an operation
+* @returns Milliseconds elapsed since `startTime`
+*
+* @example
+* ```typescript
+* const startedAt = Date.now();
+* // ... work ...
+* const durationMs = calculateDuration(startedAt);
+* ```
+*/
+const calculateDuration = (startTime) => Date.now() - startTime;
+/**
+* Extract telemetry data from an AI SDK stream result.
+* Awaits text, usage, and reasoningText in parallel for efficiency.
+*
+* @param result - AI SDK stream result to extract from
+* @returns Parsed text, usage, and optional reasoning text
+*
+* @example
+* ```typescript
+* const telemetry = await extractTelemetry(streamResult);
+* console.log(telemetry.usage.totalTokens);
+* ```
+*/
+const extractTelemetry = async (result) => {
+	const [text, usage, reasoningText] = await Promise.all([
+		result.text,
+		result.usage,
+		result.reasoningText
+	]);
+	return {
+		text,
+		usage,
+		reasoningText
+	};
+};
+/**
+* Aggregate token usage from multiple messages or operations.
+*
+* Combines usage statistics from multiple sources, handling undefined/null values safely.
+* Useful for tracking cumulative usage across a conversation or session.
+*
+* @param current - Current usage statistics
+* @param addition - Usage to add to current
+* @returns Aggregated usage statistics
+*
+* @example
+* ```typescript
+* const totalUsage = aggregateUsage(
+*   { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+*   { inputTokens: 200, outputTokens: 100, totalTokens: 300 }
+* );
+* // Returns: { inputTokens: 300, outputTokens: 150, totalTokens: 450, ... }
+* ```
+*/
+const aggregateUsage = (current, addition) => {
+	const reasoningTokens = (current.outputTokenDetails?.reasoningTokens ?? current.reasoningTokens ?? 0) + (addition.outputTokenDetails?.reasoningTokens ?? addition.reasoningTokens ?? 0);
+	const cacheReadTokens = (current.inputTokenDetails?.cacheReadTokens ?? current.cachedInputTokens ?? 0) + (addition.inputTokenDetails?.cacheReadTokens ?? addition.cachedInputTokens ?? 0);
+	const noCacheTokens = (current.inputTokenDetails?.noCacheTokens ?? 0) + (addition.inputTokenDetails?.noCacheTokens ?? 0);
+	const cacheWriteTokens = (current.inputTokenDetails?.cacheWriteTokens ?? 0) + (addition.inputTokenDetails?.cacheWriteTokens ?? 0);
+	const textTokens = (current.outputTokenDetails?.textTokens ?? 0) + (addition.outputTokenDetails?.textTokens ?? 0);
+	return {
+		inputTokens: (current.inputTokens ?? 0) + (addition.inputTokens ?? 0),
+		outputTokens: (current.outputTokens ?? 0) + (addition.outputTokens ?? 0),
+		totalTokens: (current.totalTokens ?? 0) + (addition.totalTokens ?? 0),
+		reasoningTokens,
+		cachedInputTokens: cacheReadTokens,
+		inputTokenDetails: {
+			noCacheTokens: noCacheTokens || void 0,
+			cacheReadTokens: cacheReadTokens || void 0,
+			cacheWriteTokens: cacheWriteTokens || void 0
+		},
+		outputTokenDetails: {
+			textTokens: textTokens || void 0,
+			reasoningTokens: reasoningTokens || void 0
+		}
+	};
+};
+
+//#endregion
+//#region src/server/error-handler.ts
+/**
+* @fileoverview error-handler.ts
+*/
+/** Default notifier — logs to the structured logger. */
+const defaultNotifier = createLogNotifier();
+/**
+* Type guard to check if an error is a rate limit response.
+*
+* @param {unknown} error - The error to check
+* @returns {error is RateLimitResponse} True if the error is a rate limit response
+*
+* @example
+* ```ts
+* // Check if error is a rate limit error
+* if (isRateLimitError(error)) {
+*   handleRateLimitError(error);
+* }
+* ```
+*/
+const isRateLimitError = (error) => {
+	if (error && typeof error === "object" && error !== null && "error" in error && "retryAfter" in error) {
+		const err = error;
+		return typeof err.error === "string" && typeof err.retryAfter === "number" && err.error.toLowerCase().includes("rate limit");
+	}
+	return false;
+};
+/**
+* Handles rate limit errors by notifying the user/operator.
+*
+* @param {RateLimitError} error - The rate limit error to handle
+* @param {Notifier} [notifier] - Notifier to use (defaults to log-based notifier)
+* @returns {void}
+*
+* @example
+* ```ts
+* // Handle rate limit error
+* if (isRateLimitError(error)) {
+*   handleRateLimitError(error);
+* }
+* ```
+*/
+const handleRateLimitError = (error, notifier) => {
+	const n = notifier ?? defaultNotifier;
+	const retryAfterMinutes = Math.ceil(error.retryAfter / 60);
+	const retryAfterHours = Math.ceil(retryAfterMinutes / 60);
+	let retryMessage = "";
+	if (retryAfterHours >= 1) retryMessage = `Please try again in ${retryAfterHours} hour${retryAfterHours > 1 ? "s" : ""}`;
+	else retryMessage = `Please try again in ${retryAfterMinutes} minute${retryAfterMinutes > 1 ? "s" : ""}`;
+	n.notify({
+		level: "error",
+		message: `Rate limit exceeded. You've reached the daily limit of 10 requests. ${retryMessage}`,
+		id: "rate-limit-error"
+	});
+};
+
+//#endregion
+//#region src/server/http.ts
+/**
+* @fileoverview Standard API Handlers
+*
+* Provides standardized route handlers for AI streaming endpoints.
+* Ensures consistent error handling, telemetry, and headers.
+*
+* @module @od-oneapp/ai-platform/http/handlers
+*/
+/**
+* Creates a standard POST handler for AI chat.
+* Compatible with Next.js App Router route handlers.
+*
+* @example
+* ```ts
+* export const POST = createAIHandler({ model: openai('gpt-4') });
+* ```
+*/
+function createAIHandler(options) {
+	return async function(req) {
+		try {
+			if (options.auth) {
+				if (!await options.auth(req)) return new Response(JSON.stringify({ error: "Unauthorized" }), {
+					status: 401,
+					headers: { "Content-Type": "application/json" }
+				});
+			}
+			const rawMessages = (await req.json()).messages;
+			if (!Array.isArray(rawMessages)) return new Response(JSON.stringify({ error: "Invalid messages payload" }), {
+				status: 400,
+				headers: { "Content-Type": "application/json" }
+			});
+			const maxMessages = options.maxMessages ?? 100;
+			const maxChars = options.maxChars ?? 2e5;
+			const messageSchema = z.object({
+				role: z.enum([
+					"system",
+					"user",
+					"assistant",
+					"tool"
+				]),
+				content: z.union([z.string(), z.array(z.unknown())])
+			});
+			if (!z.array(messageSchema).min(1).max(maxMessages).safeParse(rawMessages).success) return new Response(JSON.stringify({ error: "Invalid messages payload" }), {
+				status: 400,
+				headers: { "Content-Type": "application/json" }
+			});
+			if (rawMessages.reduce((sum, msg) => {
+				if (msg && typeof msg === "object" && "content" in msg) {
+					const { content } = msg;
+					if (typeof content === "string") return sum + content.length;
+					if (Array.isArray(content)) return sum + content.reduce((inner, part) => {
+						if (part && typeof part === "object" && "text" in part) {
+							const textValue = part.text;
+							return inner + (typeof textValue === "string" ? textValue.length : 0);
+						}
+						return inner;
+					}, 0);
+				}
+				return sum;
+			}, 0) > maxChars) return new Response(JSON.stringify({ error: "Messages too large" }), {
+				status: 413,
+				headers: { "Content-Type": "application/json" }
+			});
+			let messages = rawMessages;
+			if (options.compliance) {
+				const { messages: processedMessages } = await preprocessMessages(messages, options.compliance);
+				messages = processedMessages;
+			}
+			return (await streamText({
+				model: options.compliance && isLanguageModelV3(options.model) ? wrapWithCompliance(options.model, options.compliance) : options.model,
+				messages,
+				system: options.system,
+				onFinish: async ({ text }) => {
+					if (options.onFinish) await options.onFinish(text);
+				}
+			})).toTextStreamResponse();
+		} catch (error) {
+			logError("AI Handler Error", { error: error instanceof Error ? error : new Error(String(error)) });
+			return new Response(JSON.stringify({ error: "Internal Server Error" }), {
+				status: 500,
+				headers: { "Content-Type": "application/json" }
+			});
+		}
+	};
+}
+const isLanguageModelV3 = (model) => {
+	return typeof model === "object" && model !== null && "specificationVersion" in model && model.specificationVersion === "v3";
+};
+
+//#endregion
+export { STREAM_RESPONSE_OPTIONS, aggregateUsage, buildUIMessagePartsFromFinishEvent, calculateDuration, calculateModelCost, chainTransforms, checkHealth, collectDataParts, createAIHandler, createAgentRouteHandler, createCompactWindow, createDataPartExtractor, createExtendedWindow, createHealthCheckHandler, createHealthCheckMiddleware, createLargeWindow, createMessageConverter, createMessageWindow, createNextHealthCheckHandler, createOnFinishCallback, createStandardWindow, createTelemetryConfig, defaultGetMessageText, defaultValidateMessages, estimateInputTokens, extractFileAttachments, extractModelName, extractReasoningText, extractTelemetry, extractTextContent, filterByContent, filterByRole, formatConnectionError, formatErrorMessage, getErrorCode, getErrorMessage, getLastUserMessage, getLatestDataPart, groupDataPartsByType, handleRateLimitError, handleStreamResumption, inMemoryInitializeSession, initializeChatSession, initializePersistentSession, initializePersistentSessionFn, isRateLimitError, jsonError, jsonSuccess, mapStoredMessagesToUI, mapStoredToUIMessage, mergeSchemas, noopPersistMessage, noopSetupResumableStream, normalizeError, parseRequestBody, persistAssistantMessage, persistUserMessage, roundCost, setupResumableStream, transformContent, truncateText, validateMessages, wordBasedTokenizer };
+//# sourceMappingURL=server.mjs.map