@xopcai/xopc 0.0.229 → 0.0.231

package/dist/src/files/file-service.js

@@ -0,0 +1,282 @@
+import { init_agent_scope, listAgentEntries, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
+import { resolveProjectAgentId } from "../projects/project-agent.js";
+import "../projects/index.js";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { constants } from "node:fs";
+import { createHash } from "node:crypto";
+import { access, lstat, opendir, realpath, stat } from "node:fs/promises";
+//#region src/files/file-service.ts
+init_agent_scope();
+const SKIPPED_NAMES = new Set([
+	".DS_Store",
+	".git",
+	"node_modules"
+]);
+const TEXT_EXTENSIONS = new Set([
+	"css",
+	"csv",
+	"html",
+	"htm",
+	"js",
+	"json",
+	"jsx",
+	"md",
+	"mjs",
+	"cjs",
+	"svg",
+	"ts",
+	"tsx",
+	"txt",
+	"xml",
+	"yaml",
+	"yml"
+]);
+const MIME_TYPES = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+	md: "text/markdown",
+	txt: "text/plain",
+	json: "application/json",
+	html: "text/html",
+	htm: "text/html",
+	css: "text/css",
+	js: "text/javascript",
+	mjs: "text/javascript",
+	cjs: "text/javascript",
+	ts: "text/typescript",
+	tsx: "text/typescript",
+	csv: "text/csv",
+	xml: "application/xml",
+	yaml: "application/yaml",
+	yml: "application/yaml",
+	pdf: "application/pdf",
+	mp3: "audio/mpeg",
+	wav: "audio/wav",
+	ogg: "audio/ogg",
+	m4a: "audio/mp4",
+	mp4: "video/mp4",
+	mov: "video/quicktime",
+	webm: "video/webm"
+};
+function isWithin(root, target) {
+	const rel = relative(root, target);
+	return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+function normalizeRelativePath(input) {
+	const normalized = input.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
+	if (normalized.includes("\0") || normalized.split("/").some((part) => part === "..")) throw new FileServiceError(400, "Invalid file path");
+	return normalized.split("/").filter((part) => part && part !== ".").join("/");
+}
+function mimeType(name, directory) {
+	if (directory) return "inode/directory";
+	return MIME_TYPES[name.includes(".") ? name.split(".").pop().toLowerCase() : ""] ?? "application/octet-stream";
+}
+function capabilities(name, directory, writable) {
+	if (directory) return writable ? ["upload"] : [];
+	const extension = name.includes(".") ? name.split(".").pop().toLowerCase() : "";
+	const result = ["download", "share"];
+	if (MIME_TYPES[extension] || TEXT_EXTENSIONS.has(extension)) result.unshift("preview");
+	if (writable && TEXT_EXTENSIONS.has(extension)) result.push("edit");
+	return result;
+}
+function fileSpaceId(root) {
+	return createHash("sha256").update(root).digest("base64url").slice(0, 24);
+}
+function fileResourceId(spaceId, relativePath) {
+	return `${spaceId}.${Buffer.from(normalizeRelativePath(relativePath)).toString("base64url")}`;
+}
+function parseFileResourceId(id) {
+	const separator = id.indexOf(".");
+	if (separator <= 0) throw new FileServiceError(400, "Invalid file id");
+	try {
+		return {
+			spaceId: id.slice(0, separator),
+			relativePath: normalizeRelativePath(Buffer.from(id.slice(separator + 1), "base64url").toString("utf8"))
+		};
+	} catch (error) {
+		if (error instanceof FileServiceError) throw error;
+		throw new FileServiceError(400, "Invalid file id");
+	}
+}
+async function resolveFilePath(root, path, mustExist = true) {
+	const canonicalRoot = await realpath(root).catch(() => {
+		throw new FileServiceError(404, "File space is unavailable");
+	});
+	const candidate = resolve(canonicalRoot, normalizeRelativePath(path));
+	if (!isWithin(canonicalRoot, candidate)) throw new FileServiceError(400, "Invalid file path");
+	if (!mustExist) {
+		if (!isWithin(canonicalRoot, await realpath(dirname(candidate)).catch(() => {
+			throw new FileServiceError(404, "Parent directory not found");
+		}))) throw new FileServiceError(400, "Invalid file path");
+		return candidate;
+	}
+	const canonicalTarget = await realpath(candidate).catch(() => {
+		throw new FileServiceError(404, "File not found");
+	});
+	if (!isWithin(canonicalRoot, canonicalTarget)) throw new FileServiceError(400, "File is outside its space");
+	return canonicalTarget;
+}
+var FileServiceError = class extends Error {
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+	}
+};
+async function fileResourceFromPath(space, absolutePath) {
+	const info = await stat(absolutePath);
+	const revisionInfo = await stat(absolutePath, { bigint: true });
+	const relativePath = relative(await realpath(space.root), absolutePath).split(sep).join("/");
+	const name = basename(absolutePath);
+	const directory = info.isDirectory();
+	return {
+		id: fileResourceId(space.id, relativePath),
+		spaceId: space.id,
+		name,
+		relativePath,
+		parentPath: dirname(relativePath).split(sep).join("/").replace(/^\.$/, ""),
+		kind: directory ? "directory" : "file",
+		mimeType: mimeType(name, directory),
+		size: info.size,
+		modifiedAt: Math.max(0, Math.round(info.mtimeMs)),
+		revision: `${revisionInfo.mtimeNs}:${revisionInfo.ctimeNs}:${revisionInfo.ino}:${revisionInfo.size}`,
+		capabilities: capabilities(name, directory, space.writable)
+	};
+}
+var FileSpaceService = class {
+	dynamicSpaces = /* @__PURE__ */ new Map();
+	cache = null;
+	constructor(getConfig, projects, resolveSessionWorkspace) {
+		this.getConfig = getConfig;
+		this.projects = projects;
+		this.resolveSessionWorkspace = resolveSessionWorkspace;
+	}
+	async createSpace(root, title, bindings) {
+		const canonicalRoot = await realpath(root).catch(() => null);
+		if (!canonicalRoot) return null;
+		const rootStat = await stat(canonicalRoot).catch(() => null);
+		if (!rootStat?.isDirectory()) return null;
+		const writable = await access(canonicalRoot, constants.W_OK).then(() => true).catch(() => false);
+		return {
+			id: fileSpaceId(canonicalRoot),
+			title,
+			kind: "workspace",
+			bindings,
+			writable,
+			root: canonicalRoot,
+			lastActivityAt: Math.max(0, Math.round(rootStat.mtimeMs))
+		};
+	}
+	async list() {
+		if (this.cache && Date.now() - this.cache.at < 5e3) return this.cache.spaces;
+		const config = this.getConfig();
+		const spaces = [];
+		for (const agent of listAgentEntries(config)) {
+			const space = await this.createSpace(resolveAgentWorkspaceDir(config, agent.id), agent.id, [{
+				kind: "agent",
+				id: agent.id
+			}]);
+			if (space) spaces.push(space);
+		}
+		let offset = 0;
+		while (true) {
+			const page = this.projects.list({
+				limit: 500,
+				offset
+			});
+			for (const project of page.items) {
+				const agentId = resolveProjectAgentId({
+					config,
+					projects: this.projects,
+					projectId: project.id
+				});
+				const root = project.workspaceRoot ?? resolveAgentWorkspaceDir(config, agentId);
+				const space = await this.createSpace(root, project.name, [{
+					kind: "project",
+					id: project.id
+				}]);
+				if (space) spaces.push(space);
+			}
+			if (!page.hasMore || page.items.length === 0) break;
+			offset += page.items.length;
+		}
+		const merged = /* @__PURE__ */ new Map();
+		for (const space of [...spaces, ...this.dynamicSpaces.values()]) {
+			const existing = merged.get(space.id);
+			if (existing) existing.bindings = [...existing.bindings, ...space.bindings.filter((binding) => !existing.bindings.some((item) => item.kind === binding.kind && item.id === binding.id))];
+			else merged.set(space.id, {
+				...space,
+				bindings: [...space.bindings]
+			});
+		}
+		const result = [...merged.values()].sort((a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0));
+		this.cache = {
+			at: Date.now(),
+			spaces: result
+		};
+		return result;
+	}
+	async forContext(kind, id) {
+		let root;
+		let title = id;
+		if (kind === "agent") root = resolveAgentWorkspaceDir(this.getConfig(), id);
+		if (kind === "project") {
+			const project = this.projects.get(id);
+			if (project) {
+				const config = this.getConfig();
+				const agentId = resolveProjectAgentId({
+					config,
+					projects: this.projects,
+					projectId: id
+				});
+				root = project.workspaceRoot ?? resolveAgentWorkspaceDir(config, agentId);
+			}
+			title = project?.name ?? id;
+		}
+		if (kind === "session") root = this.resolveSessionWorkspace(id);
+		if (!root) throw new FileServiceError(404, "File space not found");
+		const space = await this.createSpace(root, title, [{
+			kind,
+			id
+		}]);
+		if (!space) throw new FileServiceError(404, "File space is unavailable");
+		this.dynamicSpaces.set(space.id, space);
+		this.cache = null;
+		return space;
+	}
+	async get(id) {
+		const space = (await this.list()).find((item) => item.id === id);
+		if (!space) throw new FileServiceError(404, "File space not found");
+		return space;
+	}
+	async resource(id) {
+		const locator = parseFileResourceId(id);
+		const space = await this.get(locator.spaceId);
+		const absolutePath = await resolveFilePath(space.root, locator.relativePath);
+		return {
+			space,
+			resource: await fileResourceFromPath(space, absolutePath),
+			absolutePath
+		};
+	}
+	async children(spaceId, path = "") {
+		const space = await this.get(spaceId);
+		const directory = await resolveFilePath(space.root, path);
+		if (!(await stat(directory)).isDirectory()) throw new FileServiceError(400, "Path is not a directory");
+		const entries = [];
+		const dir = await opendir(directory);
+		for await (const entry of dir) {
+			if (SKIPPED_NAMES.has(entry.name)) continue;
+			const target = resolve(directory, entry.name);
+			const linkInfo = await lstat(target).catch(() => null);
+			if (!linkInfo || linkInfo.isSymbolicLink()) continue;
+			entries.push(await fileResourceFromPath(space, target));
+		}
+		return entries.sort((a, b) => a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "directory" ? -1 : 1);
+	}
+};
+//#endregion
+export { FileServiceError, FileSpaceService, fileResourceFromPath, fileResourceId, fileSpaceId, parseFileResourceId, resolveFilePath };

package/dist/src/gateway/chat-stream/mapper.js

@@ -342,6 +342,17 @@ var ChatStreamMapper = class {
 			errorMessage: event.isError ? result?.text ?? extractText(result?.content) : void 0
 		})];
 		const details = asRecord(fullResult?.details);
+		if (toolName === "text_to_speech" && !event.isError && details) {
+			const audio = (Array.isArray(details.media) ? details.media : []).map(asRecord).find((item) => item?.type === "voice" || String(item?.mimeType ?? "").startsWith("audio/"));
+			const uri = typeof audio?.uri === "string" ? audio.uri.trim() : "";
+			if (uri) events.push(this.make("tts_audio", {
+				uri,
+				mimeType: typeof audio?.mimeType === "string" ? audio.mimeType : "audio/mpeg",
+				name: typeof audio?.name === "string" ? audio.name : "voice.mp3",
+				attachTo: "last_assistant",
+				messageId
+			}));
+		}
 		if (toolName === "exec_command" && details) events.push(this.make("command_completed", {
 			messageId,
 			toolCallId,

package/dist/src/gateway/heartbeat/service.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { shouldSilence, stripHeartbeatToken } from "../../heartbeat/tokens.js";
+import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { isWithinActiveHours } from "../../heartbeat/active-hours.js";
 import { isHeartbeatContentEmpty } from "../../heartbeat/content-check.js";
-import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { createHeartbeatWake } from "../../heartbeat/wake.js";
 import { resolveHeartbeatMdPath } from "../workspace-heartbeat-path.js";
 import { readFile } from "fs/promises";

package/dist/src/gateway/hono/app.js

@@ -155,7 +155,7 @@ function createHonoApp(config) {
 		if (/^\/api\/notes\/[^/]+\/media$/.test(path)) return true;
 		return path === "/api/notes" && contentType?.includes("multipart/form-data") === true;
 	};
-	const isProjectFileUploadRequest = (path, method, contentType) => method === "POST" && /^\/api\/projects\/[^/]+\/files\/upload$/.test(path) && contentType?.includes("multipart/form-data") === true;
+	const isFileUploadRequest = (path, method, contentType) => method === "POST" && /^\/api\/files\/spaces\/[^/]+\/upload$/.test(path) && contentType?.includes("multipart/form-data") === true;
 	const discussionUploadBodyMax = (path, method, contentType) => {
 		if (method !== "PUT" || contentType?.includes("multipart/form-data") !== true) return void 0;
 		if (/^\/api\/discussions\/[^/]+\/recording$/.test(path)) return NOTE_MEDIA_BODY_MAX;
@@ -176,7 +176,7 @@ function createHonoApp(config) {
 	}));
 	app.use("/api/*", async (c, next) => {
 		const contentType = c.req.header("content-type");
-		const maxSize = c.req.method === "POST" && c.req.path === "/api/tasks" || c.req.method === "POST" && /^\/api\/sessions\/[^/]+\/inputs$/.test(c.req.path) || c.req.method === "POST" && /^\/api\/tasks\/[^/]+\/inputs$/.test(c.req.path) || c.req.method === "PATCH" && /^\/api\/sessions\/[^/]+\/inputs\/[^/]+$/.test(c.req.path) ? SESSION_INPUT_BODY_MAX : c.req.path === "/api/skills/upload" ? SKILL_UPLOAD_BODY_MAX : c.req.path === "/api/voice/transcriptions" ? VOICE_TRANSCRIBE_BODY_MAX : c.req.path === "/api/media" && c.req.method === "POST" ? MEDIA_UPLOAD_BODY_MAX : isNoteMediaUploadRequest(c.req.path, c.req.method, contentType) ? NOTE_MEDIA_BODY_MAX : isProjectFileUploadRequest(c.req.path, c.req.method, contentType) ? NOTE_MEDIA_BODY_MAX : discussionUploadBodyMax(c.req.path, c.req.method, contentType) ?? DEFAULT_API_BODY_MAX;
+		const maxSize = c.req.method === "POST" && c.req.path === "/api/tasks" || c.req.method === "POST" && /^\/api\/sessions\/[^/]+\/inputs$/.test(c.req.path) || c.req.method === "POST" && /^\/api\/tasks\/[^/]+\/inputs$/.test(c.req.path) || c.req.method === "PATCH" && /^\/api\/sessions\/[^/]+\/inputs\/[^/]+$/.test(c.req.path) ? SESSION_INPUT_BODY_MAX : c.req.path === "/api/skills/upload" ? SKILL_UPLOAD_BODY_MAX : c.req.path === "/api/voice/transcriptions" ? VOICE_TRANSCRIBE_BODY_MAX : c.req.path === "/api/media" && c.req.method === "POST" ? MEDIA_UPLOAD_BODY_MAX : isNoteMediaUploadRequest(c.req.path, c.req.method, contentType) ? NOTE_MEDIA_BODY_MAX : isFileUploadRequest(c.req.path, c.req.method, contentType) ? NOTE_MEDIA_BODY_MAX : discussionUploadBodyMax(c.req.path, c.req.method, contentType) ?? DEFAULT_API_BODY_MAX;
 		const maxSizeMb = Math.ceil(maxSize / (1024 * 1024));
 		return bodyLimit({
 			maxSize,

package/dist/src/gateway/hono/routes/files.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function registerFilesRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/files.js

@@ -0,0 +1,172 @@
+import { FileServiceError, FileSpaceService, fileResourceFromPath, resolveFilePath } from "../../../files/file-service.js";
+import { basename, join } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+//#region src/gateway/hono/routes/files.ts
+const services = /* @__PURE__ */ new WeakMap();
+const mutationLocks = /* @__PURE__ */ new Map();
+async function withMutationLock(key, action) {
+	const previous = mutationLocks.get(key) ?? Promise.resolve();
+	let release;
+	const gate = new Promise((resolve) => {
+		release = resolve;
+	});
+	const tail = previous.then(() => gate);
+	mutationLocks.set(key, tail);
+	await previous;
+	try {
+		return await action();
+	} finally {
+		release();
+		if (mutationLocks.get(key) === tail) mutationLocks.delete(key);
+	}
+}
+function getFiles(deps) {
+	const existing = services.get(deps.service);
+	if (existing) return existing;
+	const created = new FileSpaceService(() => deps.service.currentConfig, deps.service.projects, (sessionKey) => deps.service.agentService.getResolvedWorkspaceForSession(sessionKey));
+	services.set(deps.service, created);
+	return created;
+}
+function publicSpace(space) {
+	const { root: _root, ...value } = space;
+	return value;
+}
+function errorResponse(c, error) {
+	if (error instanceof FileServiceError) return c.json({ error: { message: error.message } }, error.status);
+	throw error;
+}
+async function collectFiles(files, spaceId, query, max) {
+	const output = [];
+	const directories = [""];
+	while (directories.length && output.length < max) {
+		const directory = directories.shift();
+		const children = await files.children(spaceId, directory);
+		for (const child of children) {
+			if (child.kind === "directory") directories.push(child.relativePath);
+			else if (!query || child.name.toLocaleLowerCase().includes(query)) output.push(child);
+			if (output.length >= max) break;
+		}
+	}
+	return output;
+}
+function registerFilesRoutes(authenticated, deps) {
+	const files = getFiles(deps);
+	authenticated.get("/api/files/spaces", async (c) => {
+		try {
+			return c.json({ spaces: (await files.list()).map(publicSpace) });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.get("/api/files/contexts/:kind/:id", async (c) => {
+		try {
+			const kind = c.req.param("kind");
+			if (kind !== "agent" && kind !== "project" && kind !== "session") throw new FileServiceError(400, "Invalid context kind");
+			return c.json({ space: publicSpace(await files.forContext(kind, c.req.param("id"))) });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.get("/api/files/spaces/:id/children", async (c) => {
+		try {
+			return c.json({ items: await files.children(c.req.param("id"), c.req.query("path") ?? "") });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.get("/api/files/recent", async (c) => {
+		try {
+			const limit = Math.min(100, Math.max(1, Number(c.req.query("limit")) || 50));
+			const spaces = await files.list();
+			const items = (await Promise.all(spaces.map((space) => collectFiles(files, space.id, "", 5e3)))).flat().sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, limit);
+			return c.json({ items });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.get("/api/files/search", async (c) => {
+		try {
+			const query = (c.req.query("q") ?? "").trim().toLocaleLowerCase();
+			if (!query) return c.json({ items: [] });
+			const limit = Math.min(100, Math.max(1, Number(c.req.query("limit")) || 50));
+			const requestedSpaceId = c.req.query("spaceId");
+			const spaces = requestedSpaceId ? [await files.get(requestedSpaceId)] : await files.list();
+			const items = (await Promise.all(spaces.map((space) => collectFiles(files, space.id, query, 5e3)))).flat().sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, limit);
+			return c.json({ items });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.post("/api/files/resolve", async (c) => {
+		try {
+			const body = await c.req.json();
+			if (!body.spaceId || !body.path) throw new FileServiceError(400, "spaceId and path are required");
+			const space = await files.get(body.spaceId);
+			const absolutePath = await resolveFilePath(space.root, body.path);
+			return c.json({ resource: await fileResourceFromPath(space, absolutePath) });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.get("/api/files/:id", async (c) => {
+		try {
+			return c.json({ resource: (await files.resource(c.req.param("id"))).resource });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.get("/api/files/:id/content", async (c) => {
+		try {
+			const { resource, absolutePath } = await files.resource(c.req.param("id"));
+			if (resource.kind !== "file") throw new FileServiceError(400, "Resource is not a file");
+			if (c.req.header("if-none-match") === resource.revision) return c.body(null, 304);
+			c.header("Content-Type", resource.mimeType);
+			c.header("ETag", resource.revision);
+			c.header("Content-Disposition", `inline; filename="${resource.name.replace(/["\r\n]/g, "_")}"`);
+			return c.body(await readFile(absolutePath));
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.put("/api/files/:id/content", async (c) => {
+		try {
+			const body = await c.req.json();
+			if (typeof body.content !== "string" || !body.revision) throw new FileServiceError(400, "content and revision are required");
+			const id = c.req.param("id");
+			const resource = await withMutationLock(id, async () => {
+				const current = await files.resource(id);
+				if (!current.resource.capabilities.includes("edit")) throw new FileServiceError(403, "File is not editable");
+				if (body.revision !== current.resource.revision) throw new FileServiceError(409, "File has changed");
+				await writeFile(current.absolutePath, body.content, "utf8");
+				return fileResourceFromPath(current.space, current.absolutePath);
+			});
+			return c.json({ resource });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.post("/api/files/spaces/:id/upload", async (c) => {
+		try {
+			const space = await files.get(c.req.param("id"));
+			if (!space.writable) throw new FileServiceError(403, "File space is read-only");
+			const form = await c.req.formData();
+			const upload = form.get("file");
+			const directory = String(form.get("directory") ?? "");
+			if (!(upload instanceof File)) throw new FileServiceError(400, "file is required");
+			const name = basename(upload.name).trim();
+			if (!name || name !== upload.name) throw new FileServiceError(400, "Invalid file name");
+			const parent = await resolveFilePath(space.root, directory);
+			const target = await resolveFilePath(space.root, join(directory, name), false);
+			if (target === parent) throw new FileServiceError(400, "Invalid file name");
+			await writeFile(target, new Uint8Array(await upload.arrayBuffer()), { flag: "wx" }).catch((error) => {
+				if (error.code === "EEXIST") throw new FileServiceError(409, "File already exists");
+				throw error;
+			});
+			return c.json({ resource: await fileResourceFromPath(space, target) }, 201);
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+}
+//#endregion
+export { registerFilesRoutes };

package/dist/src/gateway/hono/routes/lazy-bundles.js

@@ -19,6 +19,14 @@ const AUTHENTICATED_LAZY_ROUTE_BUNDLES = [
 			return { register: registerMediaRoutes };
 		}
 	},
+	{
+		id: "files",
+		match: (path) => startsWithAny(path, ["/api/files"]),
+		load: async () => {
+			const { registerFilesRoutes } = await import("./files.js");
+			return { register: registerFilesRoutes };
+		}
+	},
 	{
 		id: "workspace",
 		match: (path) => startsWithAny(path, ["/api/workspace"]),