miladyai 2.0.0-alpha.27

package/dist/services/app-manager.js

@@ -0,0 +1,389 @@
+import { deriveEvmAddress, deriveSolanaAddress } from "../api/wallet.js";
+import { getPluginInfo, getRegistryPlugins } from "./registry-client.js";
+import * as path$1 from "node:path";
+import { logger } from "@elizaos/core";
+import * as fs$1 from "node:fs";
+
+//#region src/services/app-manager.ts
+/**
+* App Manager — manages app lifecycle: discover, install plugin, show viewer.
+*
+* Apps are hosted services. The manager's job is:
+* 1. List/search apps from the registry
+* 2. Install the game's plugin onto the agent (triggers restart)
+* 3. Return the viewer URL so the UI can embed the game client in an iframe
+*
+* @module services/app-manager
+*/
+const LOCAL_PLUGINS_DIR = "plugins";
+const DEFAULT_VIEWER_SANDBOX = "allow-scripts allow-same-origin allow-popups";
+const HYPERSCAPE_APP_NAME = "@elizaos/app-hyperscape";
+const HYPERSCAPE_AUTH_MESSAGE_TYPE = "HYPERSCAPE_AUTH";
+const RS_2004SCAPE_APP_NAME = "@elizaos/app-2004scape";
+const RS_2004SCAPE_AUTH_MESSAGE_TYPE = "RS_2004SCAPE_AUTH";
+const SAFE_APP_URL_PROTOCOLS = new Set(["http:", "https:"]);
+function resolvePluginPackageName(appInfo) {
+	const npmPackage = appInfo.npm.package.trim();
+	return npmPackage && npmPackage.length > 0 ? npmPackage : appInfo.name;
+}
+function mergeAppMeta(appInfo, meta) {
+	if (!meta) return;
+	appInfo.viewer = meta.viewer ?? appInfo.viewer;
+	appInfo.launchUrl = meta.launchUrl ?? appInfo.launchUrl;
+	appInfo.launchType = meta.launchType ?? appInfo.launchType;
+	appInfo.displayName = meta.displayName ?? appInfo.displayName;
+	appInfo.category = meta.category ?? appInfo.category;
+	appInfo.capabilities = meta.capabilities ?? appInfo.capabilities;
+	appInfo.icon = meta.icon ?? appInfo.icon;
+}
+function isAutoInstallable(appInfo) {
+	const supportsRuntime = appInfo.supports.v0 || appInfo.supports.v1 || appInfo.supports.v2;
+	const hasVersion = Boolean(appInfo.npm.v0Version || appInfo.npm.v1Version || appInfo.npm.v2Version);
+	return supportsRuntime && hasVersion;
+}
+/**
+* Check if a plugin exists locally in the plugins/ directory.
+* Local plugins don't need to be installed - they're already available.
+*/
+function isLocalPlugin(appInfo) {
+	const pluginsDir = path$1.resolve(process.cwd(), LOCAL_PLUGINS_DIR);
+	if (!fs$1.existsSync(pluginsDir)) return false;
+	const possibleDirs = [appInfo.name.replace(/^@[^/]+\//, ""), appInfo.name.replace("/", "-")];
+	for (const dirName of possibleDirs) {
+		const pluginPath = path$1.join(pluginsDir, dirName);
+		const pluginJsonPath = path$1.join(pluginPath, "elizaos.plugin.json");
+		if (fs$1.existsSync(pluginJsonPath)) return true;
+	}
+	return false;
+}
+function getTemplateFallbackValue(key) {
+	if (key === "RS_SDK_BOT_NAME") {
+		const runtimeBotName = process.env.BOT_NAME?.trim();
+		if (runtimeBotName && runtimeBotName.length > 0) return runtimeBotName;
+		return "testbot";
+	}
+	if (key === "HYPERSCAPE_CLIENT_URL") return "http://localhost:3333";
+	if (key === "HYPERSCAPE_SERVER_URL") return "ws://localhost:5555/ws";
+}
+function substituteTemplateVars(raw) {
+	return raw.replace(/\{([A-Z0-9_]+)\}/g, (_full, key) => {
+		const value = process.env[key];
+		if (value && value.trim().length > 0) return value.trim();
+		return getTemplateFallbackValue(key) ?? "";
+	});
+}
+function buildViewerUrl(baseUrl, embedParams) {
+	if (!embedParams || Object.keys(embedParams).length === 0) return substituteTemplateVars(baseUrl);
+	const [beforeHash, hashPartRaw] = substituteTemplateVars(baseUrl).split("#", 2);
+	const [pathPart, queryPartRaw] = beforeHash.split("?", 2);
+	const queryParams = new URLSearchParams(queryPartRaw ?? "");
+	for (const [key, rawValue] of Object.entries(embedParams)) queryParams.set(key, substituteTemplateVars(rawValue));
+	const query = queryParams.toString();
+	const hash = hashPartRaw ? `#${hashPartRaw}` : "";
+	return `${pathPart}${query.length > 0 ? `?${query}` : ""}${hash}`;
+}
+function normalizeSafeAppUrl(url) {
+	const trimmed = url.trim();
+	if (!trimmed) return null;
+	if (trimmed.startsWith("/")) return trimmed.startsWith("//") ? null : trimmed;
+	try {
+		const parsed = new URL(trimmed);
+		if (!SAFE_APP_URL_PROTOCOLS.has(parsed.protocol)) return null;
+		return trimmed;
+	} catch {
+		return null;
+	}
+}
+function buildViewerAuthMessage(appName, postMessageAuth) {
+	if (!postMessageAuth) return void 0;
+	if (appName === HYPERSCAPE_APP_NAME) {
+		const authToken = process.env.HYPERSCAPE_AUTH_TOKEN?.trim();
+		const characterId = process.env.HYPERSCAPE_CHARACTER_ID?.trim();
+		if (!authToken && !characterId) return void 0;
+		const sessionToken = process.env.HYPERSCAPE_SESSION_TOKEN?.trim();
+		const agentId = process.env.HYPERSCAPE_EMBED_AGENT_ID?.trim();
+		return {
+			type: HYPERSCAPE_AUTH_MESSAGE_TYPE,
+			authToken: authToken || void 0,
+			characterId: characterId || void 0,
+			sessionToken: sessionToken && sessionToken.length > 0 ? sessionToken : void 0,
+			agentId: agentId && agentId.length > 0 ? agentId : void 0
+		};
+	}
+	if (appName === RS_2004SCAPE_APP_NAME) return {
+		type: RS_2004SCAPE_AUTH_MESSAGE_TYPE,
+		authToken: process.env.RS_SDK_BOT_NAME?.trim() || process.env.BOT_NAME?.trim() || "testbot",
+		sessionToken: process.env.RS_SDK_BOT_PASSWORD?.trim() || process.env.BOT_PASSWORD?.trim() || ""
+	};
+}
+function buildViewerConfig(appInfo, launchUrl) {
+	const viewerInfo = appInfo.viewer;
+	if (viewerInfo) {
+		const requestedPostMessageAuth = Boolean(viewerInfo.postMessageAuth);
+		const authMessage = buildViewerAuthMessage(appInfo.name, requestedPostMessageAuth);
+		const postMessageAuth = requestedPostMessageAuth && Boolean(authMessage);
+		if (requestedPostMessageAuth && !authMessage) if (appInfo.name === HYPERSCAPE_APP_NAME) logger.info(`[app-manager] ${appInfo.name} auth token not configured; launching embedded viewer without postMessage auth.`);
+		else logger.warn(`[app-manager] ${appInfo.name} requires postMessage auth but no auth payload was generated.`);
+		const viewerUrl = normalizeSafeAppUrl(buildViewerUrl(viewerInfo.url, viewerInfo.embedParams));
+		if (!viewerUrl) throw new Error(`Refusing to launch app "${appInfo.name}": unsafe viewer URL`);
+		return {
+			url: viewerUrl,
+			embedParams: viewerInfo.embedParams,
+			postMessageAuth,
+			sandbox: viewerInfo.sandbox ?? DEFAULT_VIEWER_SANDBOX,
+			authMessage
+		};
+	}
+	if ((appInfo.launchType === "connect" || appInfo.launchType === "local") && launchUrl) {
+		const viewerUrl = normalizeSafeAppUrl(launchUrl);
+		if (!viewerUrl) throw new Error(`Refusing to launch app "${appInfo.name}": unsafe launch URL`);
+		return {
+			url: viewerUrl,
+			sandbox: DEFAULT_VIEWER_SANDBOX
+		};
+	}
+	return null;
+}
+/**
+* Get wallet addresses from agent runtime settings (character secrets).
+* Falls back to process.env if runtime is not available.
+*/
+function getWalletAddressesFromRuntime(runtime) {
+	let evmAddress = null;
+	let solanaAddress = null;
+	const evmKey = (runtime?.getSetting?.("EVM_PRIVATE_KEY"))?.trim() || process.env.EVM_PRIVATE_KEY?.trim();
+	if (evmKey) try {
+		evmAddress = deriveEvmAddress(evmKey);
+	} catch (e) {
+		logger.warn(`[app-manager] Bad EVM key: ${e}`);
+	}
+	const solKey = (runtime?.getSetting?.("SOLANA_PRIVATE_KEY"))?.trim() || process.env.SOLANA_PRIVATE_KEY?.trim();
+	if (solKey) try {
+		solanaAddress = deriveSolanaAddress(solKey);
+	} catch (e) {
+		logger.warn(`[app-manager] Bad SOL key: ${e}`);
+	}
+	return {
+		evmAddress,
+		solanaAddress
+	};
+}
+/**
+* Auto-provision a hyperscape agent using wallet-based authentication.
+* The agent's wallet address becomes its identity - no manual registration needed.
+* Uses agent.character.settings.secrets for wallet credentials.
+*/
+async function autoProvisionHyperscapeAgent(runtime) {
+	const existingCharId = (runtime?.getSetting?.("HYPERSCAPE_CHARACTER_ID"))?.trim() || process.env.HYPERSCAPE_CHARACTER_ID?.trim();
+	const existingToken = (runtime?.getSetting?.("HYPERSCAPE_AUTH_TOKEN"))?.trim() || process.env.HYPERSCAPE_AUTH_TOKEN?.trim();
+	if (existingCharId && existingToken) {
+		logger.info(`[app-manager] Hyperscape already configured with character: ${existingCharId}`);
+		return {
+			characterId: existingCharId,
+			authToken: existingToken
+		};
+	}
+	const walletAddresses = getWalletAddressesFromRuntime(runtime);
+	const walletAddress = walletAddresses.evmAddress || walletAddresses.solanaAddress;
+	if (!walletAddress) {
+		logger.warn("[app-manager] No wallet address found for hyperscape auto-auth (need EVM_PRIVATE_KEY or SOLANA_PRIVATE_KEY in character secrets)");
+		return null;
+	}
+	const walletType = walletAddresses.evmAddress ? "evm" : "solana";
+	const apiBaseUrl = ((runtime?.getSetting?.("HYPERSCAPE_SERVER_URL"))?.trim() || process.env.HYPERSCAPE_SERVER_URL?.trim() || "ws://localhost:5555/ws").replace(/^ws:/, "http:").replace(/^wss:/, "https:").replace(/\/ws$/, "");
+	const agentName = runtime?.character?.name || (runtime?.getSetting?.("BOT_NAME"))?.trim() || process.env.BOT_NAME || "Agent";
+	try {
+		logger.info(`[app-manager] Auto-provisioning hyperscape agent with wallet: ${walletAddress.slice(0, 10)}...`);
+		const response = await fetch(`${apiBaseUrl}/api/agents/wallet-auth`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				walletAddress,
+				walletType,
+				agentName
+			})
+		});
+		if (!response.ok) {
+			const errorText = await response.text().catch(() => "Unknown error");
+			logger.warn(`[app-manager] Hyperscape wallet auth failed: ${response.status} ${errorText}`);
+			return null;
+		}
+		const result = await response.json();
+		if (!result.success || !result.authToken || !result.characterId) {
+			logger.warn("[app-manager] Hyperscape wallet auth returned failure");
+			return null;
+		}
+		process.env.HYPERSCAPE_CHARACTER_ID = result.characterId;
+		process.env.HYPERSCAPE_AUTH_TOKEN = result.authToken;
+		logger.info(`[app-manager] Auto-provisioned hyperscape agent: ${result.characterId}`);
+		return {
+			characterId: result.characterId,
+			authToken: result.authToken
+		};
+	} catch (error) {
+		logger.warn(`[app-manager] Failed to auto-provision hyperscape agent: ${error instanceof Error ? error.message : String(error)}`);
+		return null;
+	}
+}
+var AppManager = class {
+	constructor() {
+		this.activeSessions = /* @__PURE__ */ new Map();
+	}
+	async listAvailable(pluginManager) {
+		const registry = await pluginManager.refreshRegistry();
+		try {
+			const localRegistry = await getRegistryPlugins();
+			for (const [name, info] of localRegistry) if (!registry.has(name) && info.kind === "app") registry.set(name, info);
+		} catch {}
+		return Array.from(registry.values()).filter((plugin) => {
+			if (plugin.kind === "app") return true;
+			const name = plugin.name.toLowerCase();
+			const npmPackage = plugin.npm.package.toLowerCase();
+			return name.includes("/app-") || npmPackage.includes("/app-");
+		}).map((p) => {
+			const meta = p.appMeta;
+			if (!meta) return p;
+			return {
+				...p,
+				displayName: meta.displayName,
+				launchType: meta.launchType,
+				launchUrl: meta.launchUrl,
+				icon: meta.icon,
+				category: meta.category,
+				capabilities: meta.capabilities,
+				viewer: meta.viewer
+			};
+		});
+	}
+	async search(pluginManager, query, limit = 15) {
+		return (await pluginManager.searchRegistry(query, limit)).filter((result) => {
+			const name = result.name.toLowerCase();
+			const npmPackage = result.npmPackage.toLowerCase();
+			return name.includes("/app-") || npmPackage.includes("/app-");
+		});
+	}
+	async getInfo(pluginManager, name) {
+		return pluginManager.getRegistryPlugin(name);
+	}
+	/**
+	* Launch an app: install its plugin (if needed) and return the viewer URL.
+	*
+	* The plugin connects the agent to the game server. The viewer URL is what
+	* the UI shows in an iframe so the user can watch the agent play.
+	*
+	* After installing a new plugin, the agent needs to restart. The UI should
+	* handle this by showing "connecting..." while the runtime restarts.
+	*/
+	async launch(pluginManager, name, onProgress, runtime) {
+		let appInfo = await pluginManager.getRegistryPlugin(name);
+		try {
+			const localInfo = await getPluginInfo(name);
+			if (localInfo) {
+				const meta = localInfo.appMeta;
+				if (!appInfo) {
+					appInfo = { ...localInfo };
+					mergeAppMeta(appInfo, meta);
+				} else if (meta && !appInfo.viewer) {
+					mergeAppMeta(appInfo, meta);
+					appInfo.kind = localInfo.kind ?? appInfo.kind;
+				}
+			}
+		} catch {}
+		if (!appInfo) throw new Error(`App "${name}" not found in the registry.`);
+		const pluginName = resolvePluginPackageName(appInfo);
+		const isLocal = isLocalPlugin(appInfo);
+		const alreadyInstalled = (await pluginManager.listInstalledPlugins()).some((p) => p.name === pluginName);
+		let pluginInstalled = alreadyInstalled || isLocal;
+		let needsRestart = false;
+		if (isLocal) logger.info(`[app-manager] Using local plugin for ${name}: ${pluginName}`);
+		else if (!alreadyInstalled) if (isAutoInstallable(appInfo)) {
+			logger.info(`[app-manager] Installing plugin for app: ${pluginName}`);
+			const result = await pluginManager.installPlugin(pluginName, onProgress);
+			if (!result.success) throw new Error(`Failed to install plugin "${pluginName}": ${result.error}`);
+			pluginInstalled = true;
+			needsRestart = result.requiresRestart;
+			logger.info(`[app-manager] Plugin installed: ${pluginName} v${result.version}`);
+		} else logger.info(`[app-manager] Skipping plugin install for ${name}: no installable runtime package/version in registry metadata.`);
+		else logger.info(`[app-manager] Plugin already installed: ${pluginName}`);
+		if (name === HYPERSCAPE_APP_NAME) {
+			if (!await autoProvisionHyperscapeAgent(runtime) && !process.env.HYPERSCAPE_CHARACTER_ID?.trim() && !process.env.HYPERSCAPE_AUTH_TOKEN?.trim()) {
+				logger.warn("[app-manager] Hyperscape requires authentication but auto-provisioning failed. Set HYPERSCAPE_CHARACTER_ID and HYPERSCAPE_AUTH_TOKEN, or ensure the hyperscape server is running.");
+				throw new Error("Hyperscape authentication required. Set HYPERSCAPE_CHARACTER_ID and HYPERSCAPE_AUTH_TOKEN, or ensure the hyperscape server is running at " + (process.env.HYPERSCAPE_SERVER_URL || "localhost:5555") + " for auto-provisioning.");
+			}
+		}
+		const resolvedLaunchUrl = appInfo.launchUrl ? substituteTemplateVars(appInfo.launchUrl) : null;
+		const launchUrl = resolvedLaunchUrl ? normalizeSafeAppUrl(resolvedLaunchUrl) : null;
+		if (resolvedLaunchUrl && !launchUrl) throw new Error(`Refusing to launch app "${appInfo.name}": unsafe launch URL`);
+		const viewer = buildViewerConfig(appInfo, launchUrl);
+		this.activeSessions.set(name, {
+			appName: name,
+			pluginName,
+			launchType: appInfo.launchType ?? "connect",
+			launchUrl,
+			viewerUrl: viewer?.url ?? null,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		return {
+			pluginInstalled,
+			needsRestart,
+			displayName: appInfo.displayName ?? appInfo.name,
+			launchType: appInfo.launchType ?? "connect",
+			launchUrl,
+			viewer
+		};
+	}
+	async stop(pluginManager, name) {
+		const appInfo = await pluginManager.getRegistryPlugin(name);
+		if (!appInfo) throw new Error(`App "${name}" not found in the registry.`);
+		const hadSession = this.activeSessions.delete(name);
+		const pluginName = resolvePluginPackageName(appInfo);
+		const isPluginInstalled = (await pluginManager.listInstalledPlugins()).some((plugin) => plugin.name === pluginName);
+		if (!hadSession && !isPluginInstalled) return {
+			success: false,
+			appName: name,
+			stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			pluginUninstalled: false,
+			needsRestart: false,
+			stopScope: "no-op",
+			message: `No active session or installed plugin found for "${name}".`
+		};
+		if (isPluginInstalled) {
+			const uninstallResult = await pluginManager.uninstallPlugin(pluginName);
+			if (!uninstallResult.success) throw new Error(`Failed to stop "${name}": ${uninstallResult.error ?? "plugin uninstall failed"}`);
+			return {
+				success: true,
+				appName: name,
+				stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				pluginUninstalled: true,
+				needsRestart: uninstallResult.requiresRestart,
+				stopScope: "plugin-uninstalled",
+				message: uninstallResult.requiresRestart ? `${name} disconnected and plugin uninstalled. Agent restart required.` : `${name} disconnected and plugin uninstalled.`
+			};
+		}
+		return {
+			success: true,
+			appName: name,
+			stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			pluginUninstalled: false,
+			needsRestart: false,
+			stopScope: "viewer-session",
+			message: `${name} viewer session stopped.`
+		};
+	}
+	/** List apps whose plugins are currently installed on the agent. */
+	async listInstalled(pluginManager) {
+		return (await pluginManager.listInstalledPlugins()).filter((p) => {
+			const name = p.name.toLowerCase();
+			return name.includes("/app-") || name === "@lunchtable/plugin-ltcg";
+		}).map((p) => ({
+			name: p.name,
+			displayName: p.name.replace(/^@elizaos\/(app-|plugin-)/, "").replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+			pluginName: p.name,
+			version: p.version ?? "unknown",
+			installedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}));
+	}
+};
+
+//#endregion
+export { AppManager };

package/dist/services/browser-capture.js

@@ -0,0 +1,86 @@
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { existsSync, writeFileSync } from "node:fs";
+import puppeteer from "puppeteer-core";
+
+//#region src/services/browser-capture.ts
+/**
+* Headless browser capture — opens a game URL in headless Chrome and
+* saves screenshots to a temp file. FFmpeg reads the temp file using
+* -loop 1 to continuously re-read the latest frame.
+*
+* This approach avoids the pipe bottleneck — FFmpeg reads at its own
+* pace while the browser updates the file independently.
+*/
+const CHROME_PATH = process.platform === "darwin" ? "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" : process.platform === "win32" ? "C:\\Program Files\\Google Chrome\\Application\\chrome.exe" : "/usr/bin/google-chrome-stable";
+let activeBrowser = null;
+let stopSignal = false;
+/** Path to the temp frame file that FFmpeg reads */
+const FRAME_FILE = join(tmpdir(), "milady-stream-frame.jpg");
+async function startBrowserCapture(config) {
+	if (activeBrowser) {
+		console.log("[browser-capture] Already running");
+		return;
+	}
+	const { url, width = 1280, height = 720, quality = 70 } = config;
+	stopSignal = false;
+	console.log(`[browser-capture] Launching headless Chrome → ${url}`);
+	const browser = await puppeteer.launch({
+		executablePath: CHROME_PATH,
+		headless: true,
+		args: [
+			`--window-size=${width},${height}`,
+			"--no-sandbox",
+			"--disable-gpu",
+			"--disable-dev-shm-usage",
+			"--disable-extensions",
+			"--mute-audio"
+		]
+	});
+	activeBrowser = browser;
+	const page = await browser.newPage();
+	await page.setViewport({
+		width,
+		height
+	});
+	await page.goto(url, {
+		waitUntil: "domcontentloaded",
+		timeout: 3e4
+	});
+	console.log(`[browser-capture] Page loaded, writing frames to ${FRAME_FILE}`);
+	const cdp = await page.createCDPSession();
+	let frameCount = 0;
+	cdp.on("Page.screencastFrame", async (params) => {
+		if (stopSignal) return;
+		try {
+			const buf = Buffer.from(params.data, "base64");
+			if (buf.length > 0) {
+				writeFileSync(FRAME_FILE, buf);
+				frameCount++;
+				if (frameCount % 100 === 0) console.log(`[browser-capture] ${frameCount} frames written`);
+			}
+			await cdp.send("Page.screencastFrameAck", { sessionId: params.sessionId });
+		} catch {}
+	});
+	await cdp.send("Page.startScreencast", {
+		format: "jpeg",
+		quality,
+		maxWidth: width,
+		maxHeight: height,
+		everyNthFrame: 2
+	});
+	console.log(`[browser-capture] CDP screencast active, saving to ${FRAME_FILE}`);
+}
+async function stopBrowserCapture() {
+	stopSignal = true;
+	if (activeBrowser) {
+		try {
+			await activeBrowser.close();
+		} catch {}
+		activeBrowser = null;
+	}
+	console.log("[browser-capture] Stopped");
+}
+
+//#endregion
+export { FRAME_FILE, startBrowserCapture, stopBrowserCapture };

package/dist/services/fallback-training-service.js

@@ -0,0 +1,128 @@
+import crypto from "node:crypto";
+
+//#region src/services/fallback-training-service.ts
+var FallbackTrainingService = class {
+	constructor(options) {
+		this.options = options;
+		this.listeners = /* @__PURE__ */ new Set();
+		this.datasets = [];
+		this.jobs = [];
+		this.models = [];
+	}
+	async initialize() {}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	emit(event) {
+		for (const listener of this.listeners) try {
+			listener(event);
+		} catch {}
+	}
+	getStatus() {
+		return {
+			runningJobs: this.jobs.filter((job) => job.status === "running").length,
+			datasetCount: this.datasets.length,
+			modelCount: this.models.length
+		};
+	}
+	async listTrajectories(options) {
+		const limit = options.limit ?? 100;
+		const offset = options.offset ?? 0;
+		if (!this.options.getRuntime()) return {
+			available: false,
+			reason: "runtime_not_started",
+			trajectories: [],
+			total: 0,
+			limit,
+			offset
+		};
+		return {
+			available: false,
+			reason: "trajectory_store_unavailable",
+			trajectories: [],
+			total: 0,
+			limit,
+			offset
+		};
+	}
+	async getTrajectoryById(_trajectoryId) {
+		return null;
+	}
+	listDatasets() {
+		return [...this.datasets];
+	}
+	async buildDataset(options) {
+		const dataset = {
+			id: `dataset-${crypto.randomUUID()}`,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			limit: options.limit,
+			minLlmCallsPerTrajectory: options.minLlmCallsPerTrajectory
+		};
+		this.datasets.unshift(dataset);
+		this.emit({
+			kind: "dataset_built",
+			dataset
+		});
+		return dataset;
+	}
+	listJobs() {
+		return [...this.jobs];
+	}
+	async startTrainingJob(options) {
+		if (!options.datasetId) throw new Error("datasetId is required");
+		if (!this.datasets.some((dataset) => dataset.id === options.datasetId)) throw new Error("Dataset not found");
+		const job = {
+			id: `job-${crypto.randomUUID()}`,
+			datasetId: options.datasetId,
+			status: "queued",
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.jobs.unshift(job);
+		this.emit({
+			kind: "job_started",
+			job
+		});
+		return job;
+	}
+	getJob(jobId) {
+		return this.jobs.find((job) => job.id === jobId) ?? null;
+	}
+	async cancelJob(jobId) {
+		const job = this.getJob(jobId);
+		if (!job) throw new Error("Training job not found");
+		job.status = "cancelled";
+		this.emit({
+			kind: "job_cancelled",
+			job
+		});
+		return job;
+	}
+	listModels() {
+		return [...this.models];
+	}
+	async importModelToOllama(modelId, _body) {
+		const model = this.models.find((entry) => entry.id === modelId);
+		if (!model) throw new Error("Model not found");
+		return model;
+	}
+	async activateModel(modelId, _providerModel) {
+		const model = this.models.find((entry) => entry.id === modelId);
+		if (!model) throw new Error("Model not found");
+		return {
+			ok: true,
+			activeModelId: model.id
+		};
+	}
+	async benchmarkModel(modelId) {
+		const model = this.models.find((entry) => entry.id === modelId);
+		if (!model) throw new Error("Model not found");
+		return {
+			ok: true,
+			modelId: model.id
+		};
+	}
+};
+
+//#endregion
+export { FallbackTrainingService };