@xopcai/xopc 0.0.321 → 0.0.323

package/dist/src/extensions/agent-plugins/validation.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+export declare const PLUGIN_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+export declare const MCP_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+export declare const pluginName: z.ZodString;
+declare const manifestSchema: z.ZodObject<{
+    $schema: z.ZodLiteral<"https://agent-plugins.org/schemas/1.0.0/plugin.schema.json">;
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    homepage: z.ZodOptional<z.ZodString>;
+    repository: z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const serverSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"stdio">;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"streamable-http">;
+    url: z.ZodString;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"sse">;
+    url: z.ZodString;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>], "type">;
+export type PluginManifest = z.infer<typeof manifestSchema>;
+export type PluginServer = z.infer<typeof serverSchema>;
+export interface PluginDiagnostic {
+    component: string;
+    message: string;
+}
+export interface PluginInspection {
+    manifest: PluginManifest;
+    rootDir: string;
+    skills: Array<{
+        name: string;
+        filePath: string;
+    }>;
+    servers: Record<string, PluginServer>;
+    capabilities: string[];
+    diagnostics: PluginDiagnostic[];
+}
+export declare function containedPath(root: string, path: string): string;
+export declare function expandPluginVariables(value: string, root: string, data: string): string;
+export declare function resolvePluginCwd(cwd: string | undefined, root: string, data: string): string;
+export declare function validatePluginServer(raw: unknown, root: string, data: string): PluginServer;
+export declare function inspectAgentPlugin(rootDir: string, dataDir?: string): PluginInspection;
+export declare function pluginServerId(pluginId: string, serverName: string): string;
+export {};

package/dist/src/extensions/agent-plugins/validation.js

@@ -0,0 +1,211 @@
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { z } from "zod";
+import { validateHeaderName, validateHeaderValue } from "node:http";
+import yaml from "js-yaml";
+//#region src/extensions/agent-plugins/validation.ts
+const PLUGIN_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+const MCP_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+const pluginName = z.string().min(1).max(64).regex(/^(?!.*(?:--|\.\.))[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/);
+const manifestSchema = z.object({
+	$schema: z.literal(PLUGIN_SCHEMA),
+	name: pluginName,
+	version: z.string().optional(),
+	description: z.string().optional(),
+	author: z.strictObject({
+		name: z.string().optional(),
+		email: z.string().optional(),
+		url: z.string().optional()
+	}).optional(),
+	homepage: z.string().optional(),
+	repository: z.string().optional(),
+	license: z.string().optional(),
+	keywords: z.array(z.string()).optional(),
+	extensions: z.record(z.string(), z.unknown()).optional()
+});
+const strings = z.record(z.string(), z.string());
+const serverSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("stdio"),
+		command: z.string().min(1),
+		args: z.array(z.string()).optional(),
+		env: strings.optional(),
+		cwd: z.string().optional()
+	}),
+	z.strictObject({
+		type: z.literal("streamable-http"),
+		url: z.string().min(1),
+		headers: strings.optional()
+	}),
+	z.strictObject({
+		type: z.literal("sse"),
+		url: z.string().min(1),
+		headers: strings.optional()
+	})
+]);
+function containedPath(root, path) {
+	const base = resolve(root);
+	const target = resolve(path);
+	const rel = relative(base, target);
+	if (rel === ".." || rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(rel)) throw new Error("Path escapes package boundary");
+	let ancestor = target;
+	while (!existsSync(ancestor)) {
+		try {
+			lstatSync(ancestor);
+			throw new Error("Broken package symlink");
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		if (dirname(ancestor) === ancestor) break;
+		ancestor = dirname(ancestor);
+	}
+	let baseAncestor = base;
+	while (!existsSync(baseAncestor)) baseAncestor = dirname(baseAncestor);
+	const canonicalBase = resolve(realpathSync(baseAncestor), relative(baseAncestor, base));
+	const canonicalTarget = resolve(realpathSync(ancestor), relative(ancestor, target));
+	const resolvedRelative = relative(canonicalBase, canonicalTarget);
+	if (resolvedRelative === ".." || resolvedRelative.startsWith("../") || resolvedRelative.startsWith("..\\") || isAbsolute(resolvedRelative)) throw new Error("Resolved path escapes package boundary");
+	return canonicalTarget;
+}
+function readPackageFile(root, path) {
+	const safe = containedPath(root, path);
+	const stat = statSync(safe);
+	if (!stat.isFile() || stat.size > 1024 * 1024) throw new Error("Expected a regular file of at most 1 MiB");
+	return readFileSync(safe, "utf8");
+}
+function expandPluginVariables(value, root, data) {
+	return value.replace(/\$\{PLUGIN_(ROOT|DATA)\}/g, (_, key) => key === "ROOT" ? root : data);
+}
+function resolvePluginCwd(cwd, root, data) {
+	if (cwd === void 0) return root;
+	const dataRooted = /^\$\{PLUGIN_DATA\}(?:\/|$)/.test(cwd);
+	if (!dataRooted && !/^(?:\.\/|\$\{PLUGIN_ROOT\}(?:\/|$))/.test(cwd)) throw new Error("Invalid MCP cwd");
+	return containedPath(dataRooted ? data : root, resolve(root, expandPluginVariables(cwd, root, data)));
+}
+function validatePluginServer(raw, root, data) {
+	const server = serverSchema.parse(raw);
+	if (server.type === "stdio") {
+		if (server.command.startsWith("./")) {
+			if (!statSync(containedPath(root, resolve(root, server.command))).isFile()) throw new Error("MCP command must be a file");
+		} else if (!/^[^\s/\\:;|&<>`$\x00-\x1f]+$/.test(server.command)) throw new Error("MCP command must be one bare executable or ./package-path");
+		for (const key of Object.keys(server.env ?? {})) {
+			if (["PLUGIN_ROOT", "PLUGIN_DATA"].includes(process.platform === "win32" ? key.toUpperCase() : key)) throw new Error("Reserved plugin environment variable");
+			if (!key || /[=\0]/.test(key)) throw new Error("Invalid environment name");
+		}
+		if ([
+			...server.args ?? [],
+			...Object.values(server.env ?? {}),
+			server.command,
+			server.cwd ?? ""
+		].some((value) => value.includes("\0"))) throw new Error("NUL in process configuration");
+		resolvePluginCwd(server.cwd, root, data);
+	} else {
+		const url = new URL(server.url);
+		const loopback = url.hostname === "localhost" || url.hostname === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(url.hostname);
+		if (!["https:", "http:"].includes(url.protocol) || url.protocol === "http:" && !loopback || url.username || url.password || server.url.includes("#")) throw new Error("Remote MCP requires HTTPS (HTTP is allowed on loopback), without user information or fragments");
+		const names = /* @__PURE__ */ new Set();
+		for (const [key, value] of Object.entries(server.headers ?? {})) {
+			validateHeaderName(key);
+			validateHeaderValue(key, value);
+			if (names.has(key.toLowerCase())) throw new Error("Duplicate case-insensitive header");
+			names.add(key.toLowerCase());
+		}
+	}
+	return server;
+}
+function inspectAgentPlugin(rootDir, dataDir = join(rootDir, ".inspection-data")) {
+	const root = realpathSync(rootDir);
+	if (existsSync(join(root, "xopc.extension.json"))) throw new Error("This package is a native xopc extension");
+	if (existsSync(join(root, "package.json"))) {
+		if (JSON.parse(readPackageFile(root, join(root, "package.json")))?.xopc?.extension) throw new Error("This package is a native xopc extension");
+	}
+	const raw = JSON.parse(readPackageFile(root, join(root, "plugin.json")));
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("Plugin manifest must be an object");
+	const diagnostics = [];
+	const cleaned = { ...raw };
+	for (const key of Object.keys(cleaned)) if (!Object.hasOwn(manifestSchema.shape, key)) {
+		diagnostics.push({
+			component: "manifest",
+			message: `Ignored unknown field: ${key}`
+		});
+		delete cleaned[key];
+	}
+	if ("extensions" in cleaned && (!cleaned.extensions || typeof cleaned.extensions !== "object" || Array.isArray(cleaned.extensions))) {
+		diagnostics.push({
+			component: "manifest",
+			message: "Ignored non-object extensions field"
+		});
+		delete cleaned.extensions;
+	}
+	const result = {
+		manifest: manifestSchema.parse(cleaned),
+		rootDir: root,
+		skills: [],
+		servers: Object.create(null),
+		capabilities: [],
+		diagnostics
+	};
+	const attempt = (component, fn) => {
+		try {
+			fn();
+		} catch (error) {
+			diagnostics.push({
+				component,
+				message: error instanceof Error ? error.message : String(error)
+			});
+		}
+	};
+	const present = (path) => {
+		try {
+			lstatSync(path);
+			return true;
+		} catch (error) {
+			if (error.code === "ENOENT") return false;
+			throw error;
+		}
+	};
+	const skillsDir = join(root, "skills");
+	if (present(skillsDir)) attempt("skills", () => {
+		const safe = containedPath(root, skillsDir);
+		if (!statSync(safe).isDirectory()) throw new Error("skills must be a directory");
+		for (const name of readdirSync(safe).sort()) attempt(`skill:${name}`, () => {
+			const dir = containedPath(root, join(safe, name));
+			if (!statSync(dir).isDirectory() || !present(join(dir, "SKILL.md"))) return;
+			const filePath = containedPath(root, join(dir, "SKILL.md"));
+			const match = readPackageFile(root, filePath).match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+			if (!match) throw new Error("Skill requires YAML frontmatter");
+			const metadata = z.object({
+				name: z.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+				description: z.string().min(1).max(1024),
+				license: z.string().optional(),
+				compatibility: z.string().min(1).max(500).optional(),
+				metadata: strings.optional(),
+				"allowed-tools": z.string().optional()
+			}).parse(yaml.load(match[1], { schema: yaml.JSON_SCHEMA }));
+			if (metadata.name !== name || !metadata.description.trim()) throw new Error("Skill name must match its directory and description must not be blank");
+			result.skills.push({
+				name,
+				filePath
+			});
+		});
+	});
+	const mcpPath = join(root, "mcp.json");
+	if (present(mcpPath)) attempt("mcp", () => {
+		const mcp = z.strictObject({
+			$schema: z.literal(MCP_SCHEMA),
+			mcpServers: z.record(z.string(), z.unknown())
+		}).parse(JSON.parse(readPackageFile(root, mcpPath)));
+		for (const [name, rawServer] of Object.entries(mcp.mcpServers)) attempt(`mcp:${name}`, () => {
+			result.servers[name] = validatePluginServer(rawServer, root, dataDir);
+		});
+	});
+	for (const skill of result.skills) result.capabilities.push(`content.skills:${skill.name}`);
+	for (const [name, server] of Object.entries(result.servers)) result.capabilities.push(server.type === "stdio" ? `runtime.mcp.stdio:${name}:${JSON.stringify(server)}` : `network.mcp:${name}:${server.type}:${server.url}:${JSON.stringify(server.headers ?? {})}`);
+	result.capabilities.sort();
+	return result;
+}
+function pluginServerId(pluginId, serverName) {
+	return `plugin/${encodeURIComponent(pluginId)}/${encodeURIComponent(serverName)}`;
+}
+//#endregion
+export { MCP_SCHEMA, PLUGIN_SCHEMA, containedPath, expandPluginVariables, inspectAgentPlugin, pluginName, pluginServerId, resolvePluginCwd, validatePluginServer };

package/dist/src/extensions/update.js

@@ -2,8 +2,8 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { init_paths, resolveBundledExtensionsDir, resolveExtensionsDir } from "../config/paths.js";
 import { init_loader, loadConfig } from "../config/loader.js";
-import { downloadExtensionStoreZipBuffer, resolveExtensionZipDownloadUrl, resolveExtensionsStoreBaseUrl, verifyStoreArtifactSha256 } from "../agent/skills/marketplace/adapters/store/store-api-client.js";
 import { computeExtensionDirectoryIntegrity, getExtensionLockfileManager } from "./lockfile.js";
+import { downloadExtensionStoreZipBuffer, resolveExtensionZipDownloadUrl, resolveExtensionsStoreBaseUrl, verifyStoreArtifactSha256 } from "../agent/skills/marketplace/adapters/store/store-api-client.js";
 import { commitStagedExtensionInstall, finalizeStagedExtensionInstall, rollbackStagedExtensionInstall, stageExtensionNpm, stageExtensionStoreZip } from "./install-transaction.js";
 import { findExtension } from "./marketplace.js";
 import { join } from "node:path";

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

@@ -1,5 +1,6 @@
 import { parseTurnOutcome } from "../../../packages/gateway-contract/src/turn-outcome.js";
 import { resolveToolActivity } from "../../../packages/gateway-contract/src/tool-activity.js";
+import { isUserTurnDocument } from "../../../packages/gateway-contract/src/user-turn-document.js";
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { createPetFeedback } from "./pet-feedback.js";
 //#region src/gateway/chat-stream/mapper.ts
@@ -446,12 +447,15 @@ function userMessageFromEvent(event, turnId) {
 	};
 }
 function userMessageDisplayMetadata(value) {
-	const rows = asRecord(value)?.sourceContexts;
-	if (!Array.isArray(rows)) return void 0;
+	const metadata = asRecord(value);
+	const rows = metadata?.sourceContexts;
+	const userTurnDocument = isUserTurnDocument(metadata?.userTurnDocument) ? metadata.userTurnDocument : void 0;
+	if (!Array.isArray(rows)) return userTurnDocument ? { userTurnDocument } : void 0;
 	const sourceContexts = rows.flatMap((value) => {
 		const row = asRecord(value);
 		if (row?.kind !== "note" && row?.kind !== "task" && row?.kind !== "file" && row?.kind !== "session" && row?.kind !== "browser_tab" && row?.kind !== "mcp_resource" || typeof row.sourceId !== "string" || typeof row.version !== "string" || typeof row.title !== "string") return [];
 		return [{
+			...typeof row.refId === "string" ? { refId: row.refId } : {},
 			kind: row.kind,
 			sourceId: row.sourceId,
 			version: row.version,
@@ -461,7 +465,10 @@ function userMessageDisplayMetadata(value) {
 			...row.kind === "file" && (row.fileKind === "file" || row.fileKind === "directory") ? { fileKind: row.fileKind } : {}
 		}];
 	});
-	return sourceContexts.length > 0 ? { sourceContexts } : void 0;
+	return sourceContexts.length > 0 || userTurnDocument ? {
+		...sourceContexts.length > 0 ? { sourceContexts } : {},
+		...userTurnDocument ? { userTurnDocument } : {}
+	} : void 0;
 }
 function extractTextFromMessage(message) {
 	return extractText(message.content);

package/dist/src/gateway/hono/routes/agent-plugins.d.ts

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

package/dist/src/gateway/hono/routes/agent-plugins.js

@@ -0,0 +1,166 @@
+import { AgentPluginStore } from "../../../extensions/agent-plugins/store.js";
+import { removePluginCredentials, savePluginAuthBinding } from "../../../extensions/agent-plugins/auth.js";
+import { disposeAllSessionMcpRuntimes } from "../../../agent/mcp/bundle-mcp-runtime.js";
+import { withAgentPluginSource } from "../../../extensions/agent-plugins/sources.js";
+import { agentPluginInventoryRow } from "../../../extensions/agent-plugins/inventory.js";
+import { z } from "zod";
+//#region src/gateway/hono/routes/agent-plugins.ts
+const sourceBody = z.strictObject({
+	source: z.string().min(1),
+	reviewHash: z.string().optional()
+});
+function registerAgentPluginRoutes(app, deps) {
+	const store = new AgentPluginStore();
+	const refresh = async () => {
+		await disposeAllSessionMcpRuntimes();
+		deps.service.marketplace.reloadSkills();
+	};
+	app.post("/api/extensions/inspect", deps.strictRateLimitMiddleware, async (c) => {
+		try {
+			const body = sourceBody.parse(await c.req.json());
+			return c.json({
+				ok: true,
+				payload: await withAgentPluginSource(body.source, deps.service.currentConfig, (source) => store.inspect(source))
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	app.post("/api/extensions/install", deps.strictRateLimitMiddleware, async (c) => {
+		try {
+			const body = sourceBody.parse(await c.req.json());
+			const plugin = await withAgentPluginSource(body.source, deps.service.currentConfig, (source) => store.install(source, {
+				reviewHash: body.reviewHash,
+				sourceLabel: body.source
+			}));
+			await refresh();
+			return c.json({
+				ok: true,
+				payload: agentPluginInventoryRow(plugin)
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	app.get("/api/extensions/agent-plugins/:id", (c) => {
+		try {
+			const plugin = store.get(c.req.param("id"));
+			return plugin ? c.json({
+				ok: true,
+				payload: agentPluginInventoryRow(plugin)
+			}) : c.json({
+				ok: false,
+				error: "Plugin not found"
+			}, 404);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	app.post("/api/extensions/agent-plugins/:id/activation", deps.strictRateLimitMiddleware, async (c) => {
+		try {
+			const body = z.strictObject({ enabled: z.boolean() }).parse(await c.req.json());
+			const plugin = store.setEnabled(c.req.param("id"), body.enabled);
+			await refresh();
+			return c.json({
+				ok: true,
+				payload: agentPluginInventoryRow(plugin)
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	app.post("/api/extensions/agent-plugins/:id/update", deps.strictRateLimitMiddleware, async (c) => {
+		try {
+			const body = sourceBody.parse(await c.req.json());
+			const plugin = await withAgentPluginSource(body.source, deps.service.currentConfig, (source) => store.install(source, {
+				reviewHash: body.reviewHash,
+				replace: true,
+				expectedId: c.req.param("id"),
+				sourceLabel: body.source
+			}));
+			await refresh();
+			return c.json({
+				ok: true,
+				payload: agentPluginInventoryRow(plugin)
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	app.post("/api/extensions/agent-plugins/:id/rollback", deps.strictRateLimitMiddleware, async (c) => {
+		try {
+			const plugin = store.rollback(c.req.param("id"));
+			await refresh();
+			return c.json({
+				ok: true,
+				payload: agentPluginInventoryRow(plugin)
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	app.put("/api/extensions/agent-plugins/:id/mcp/:server/auth", deps.strictRateLimitMiddleware, async (c) => {
+		try {
+			const body = z.strictObject({
+				mode: z.enum([
+					"auto",
+					"oauth",
+					"api-key",
+					"none"
+				]),
+				secrets: z.array(z.strictObject({
+					target: z.enum(["headers", "env"]),
+					key: z.string(),
+					value: z.string(),
+					prefix: z.string().optional()
+				})).max(20).optional()
+			}).parse(await c.req.json());
+			await savePluginAuthBinding(store, c.req.param("id"), c.req.param("server"), body);
+			await refresh();
+			return c.json({ ok: true });
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	app.delete("/api/extensions/agent-plugins/:id", deps.strictRateLimitMiddleware, async (c) => {
+		try {
+			const body = z.strictObject({
+				removeData: z.boolean().optional(),
+				removeCredentials: z.boolean().optional()
+			}).parse(await c.req.json());
+			await disposeAllSessionMcpRuntimes();
+			if (body.removeCredentials) await removePluginCredentials(store, c.req.param("id"));
+			store.remove(c.req.param("id"), body.removeData);
+			deps.service.marketplace.reloadSkills();
+			return c.json({ ok: true });
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+}
+//#endregion
+export { registerAgentPluginRoutes };

package/dist/src/gateway/hono/routes/agent-stream.js

@@ -1,7 +1,10 @@
+import { parseUserTurnDocument, userTurnDocumentRefIds } from "../../../../packages/gateway-contract/src/user-turn-document.js";
+import { init_src } from "../../../../packages/gateway-contract/src/index.js";
 import { validateWebchatAttachments, validateWebchatContent } from "../../chat-limits.js";
 import { parseTurnContextRefs } from "../../../agent/source-context/types.js";
 import { replaceLatestSessionTurn, submitSessionInput } from "./session-input-handler.js";
 //#region src/gateway/hono/routes/agent-stream.ts
+init_src();
 function registerAgentStreamRoutes(authenticated, deps) {
 	const { service, chatRateLimitMiddleware } = deps;
 	authenticated.post("/api/agent/abort", chatRateLimitMiddleware, async (c) => {
@@ -60,6 +63,17 @@ function registerAgentStreamRoutes(authenticated, deps) {
 				message: "Invalid source context references"
 			}
 		}, 400);
+		if (typeof body.content === "string") {
+			const document = parseUserTurnDocument(body.content);
+			const refIds = new Set((contextRefs ?? []).flatMap((ref) => ref.refId ? [ref.refId] : []));
+			if (document && !userTurnDocumentRefIds(document).every((refId) => refIds.has(refId))) return c.json({
+				ok: false,
+				error: {
+					code: "BAD_REQUEST",
+					message: "Input contains an unknown context reference"
+				}
+			}, 400);
+		}
 		if (body.content !== void 0) {
 			const contentError = validateWebchatContent(body.content);
 			if (contentError) return c.json({

package/dist/src/gateway/hono/routes/auth-registry-extensions.js

@@ -7,6 +7,7 @@ import { createOAuthAsyncHandler } from "../oauth-async.js";
 import { createOAuthHandler } from "../oauth.js";
 import { extensionAssetMimeType } from "../lib/extension-assets.js";
 import { loadExtensionStore, saveExtensionStore } from "../lib/extension-store.js";
+import { listAgentPluginInventory } from "../../../extensions/agent-plugins/inventory.js";
 import { relative, resolve } from "node:path";
 import { existsSync, readFileSync, statSync } from "node:fs";
 //#region src/gateway/hono/routes/auth-registry-extensions.ts
@@ -152,7 +153,7 @@ function registerAuthRegistryExtensionsRoutes(authenticated, deps) {
 	});
 	authenticated.get("/api/extensions", async (c) => {
 		const loader = service.getExtensionLoader();
-		if (!loader) return c.json({ extensions: [] });
+		if (!loader) return c.json({ extensions: listAgentPluginInventory() });
 		const registry = loader.getRegistry();
 		const discovered = loader.discoverExtensions();
 		const activeIds = /* @__PURE__ */ new Set();
@@ -166,6 +167,7 @@ function registerAuthRegistryExtensionsRoutes(authenticated, deps) {
 			activationEligibleIds = /* @__PURE__ */ new Set();
 		}
 		const extensions = discovered.map((ext) => ({
+			format: "native-extension",
 			id: ext.manifest.id,
 			name: ext.manifest.name,
 			description: ext.manifest.description,
@@ -182,7 +184,7 @@ function registerAuthRegistryExtensionsRoutes(authenticated, deps) {
 				contributions: ext.manifest.ui.contributions
 			} : void 0
 		}));
-		return c.json({ extensions });
+		return c.json({ extensions: [...extensions, ...listAgentPluginInventory()] });
 	});
 	/**
 	* Built-in (bundled) extension enable/disable — persists `extensions.enabled` / `extensions.disabled`.

package/dist/src/gateway/hono/routes/chat-previews.d.ts

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

package/dist/src/gateway/hono/routes/chat-previews.js

@@ -0,0 +1,41 @@
+import { ChatPreviewFixGuidanceInputSchema, ChatPreviewSourceHashSchema } from "../../../../packages/gateway-contract/src/chat-previews.js";
+import { init_src } from "../../../../packages/gateway-contract/src/index.js";
+import { ChatPreviewNotFoundError } from "../../../chat-previews/service.js";
+import "../../../chat-previews/index.js";
+//#region src/gateway/hono/routes/chat-previews.ts
+init_src();
+function registerChatPreviewRoutes(app, deps) {
+	app.get("/api/chat-previews/:id/revisions/:sourceHash", (c) => {
+		const sourceHash = ChatPreviewSourceHashSchema.safeParse(c.req.param("sourceHash"));
+		if (!sourceHash.success) return c.json({ error: "Invalid preview revision" }, 400);
+		try {
+			return c.json({ revision: deps.service.chatPreviews.getRevision(c.req.param("id"), sourceHash.data) }, 200, { "Cache-Control": "private, max-age=31536000, immutable" });
+		} catch (error) {
+			if (error instanceof ChatPreviewNotFoundError) return c.json({ error: error.message }, 404);
+			throw error;
+		}
+	});
+	app.post("/api/chat-previews/:id/fix-guidance", async (c) => {
+		const parsed = ChatPreviewFixGuidanceInputSchema.safeParse(await c.req.json().catch(() => null));
+		if (!parsed.success) return c.json({ error: "Invalid fix guidance input" }, 400);
+		try {
+			return c.json({ guidance: deps.service.chatPreviews.getFixGuidance(c.req.param("id"), parsed.data.sourceHash, parsed.data.diagnostics, parsed.data.locale) });
+		} catch (error) {
+			if (error instanceof ChatPreviewNotFoundError) return c.json({ error: error.message }, 404);
+			throw error;
+		}
+	});
+	app.post("/api/chat-previews/:id/promote", async (c) => {
+		const body = await c.req.json().catch(() => null);
+		const sourceHash = ChatPreviewSourceHashSchema.safeParse(body?.sourceHash);
+		if (!sourceHash.success) return c.json({ error: "Invalid preview revision" }, 400);
+		try {
+			return c.json({ app: deps.service.chatPreviews.promote(c.req.param("id"), sourceHash.data) }, 201);
+		} catch (error) {
+			if (error instanceof ChatPreviewNotFoundError) return c.json({ error: error.message }, 404);
+			throw error;
+		}
+	});
+}
+//#endregion
+export { registerChatPreviewRoutes };

package/dist/src/gateway/hono/routes/connection-waits.js

@@ -13,11 +13,13 @@ const actionSchema = z.object({
 		"cancel",
 		"select_account",
 		"confirm_scope",
-		"replace_source"
+		"replace_source",
+		"submit_callback"
 	]),
 	candidateRef: z.string().optional(),
 	needKey: z.string().optional(),
-	accountId: z.string().optional()
+	accountId: z.string().optional(),
+	callbackUrl: z.string().max(16384).optional()
 }).strict();
 function registerConnectionWaitRoutes(app, { service, strictRateLimitMiddleware }) {
 	app.get("/api/sessions/:conversationId/connection-wait", (c) => {

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

@@ -16,6 +16,7 @@ import { registerEndpointToolRoutes } from "./endpoint-tools.js";
 import { registerRealtimeRoutes } from "./realtime.js";
 import { registerDeviceRoutes } from "./devices.js";
 import { registerLocalAppsRoutes } from "./local-apps.js";
+import { registerChatPreviewRoutes } from "./chat-previews.js";
 import { registerWorkDiscoveryRoutes } from "./work-discovery.js";
 import { registerContextSourceRoutes } from "./context-sources.js";
 import { registerTaskRoutes } from "./tasks.js";
@@ -34,6 +35,7 @@ function registerCoreAuthenticatedRoutes(authenticated, deps) {
 	registerProjectsRoutes(authenticated, deps);
 	registerProjectSkillRoutes(authenticated, deps);
 	registerLocalAppsRoutes(authenticated, deps);
+	registerChatPreviewRoutes(authenticated, deps);
 	registerWorkDiscoveryRoutes(authenticated, deps);
 	registerContextSourceRoutes(authenticated, deps);
 	registerTaskRoutes(authenticated, deps);

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

@@ -3,6 +3,14 @@ function startsWithAny(path, prefixes) {
 	return prefixes.some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
 }
 const AUTHENTICATED_LAZY_ROUTE_BUNDLES = [
+	{
+		id: "agent-plugins",
+		match: (path) => path === "/api/extensions/inspect" || path === "/api/extensions/install" || startsWithAny(path, ["/api/extensions/agent-plugins"]),
+		load: async () => {
+			const { registerAgentPluginRoutes } = await import("./agent-plugins.js");
+			return { register: registerAgentPluginRoutes };
+		}
+	},
 	{
 		id: "local-app-capabilities",
 		match: (path) => /^\/api\/local-app-capabilities\/[^/]+(?:\/[^/]+\/invocations)?$/.test(path),