fengming 0.3.8 → 0.3.9

package/dist/server-cron-DdR-ugiU.js

@@ -1,2 +0,0 @@
-import { t as buildGatewayCronService } from "./server-cron-Bkzb9edh.js";
-export { buildGatewayCronService };

package/dist/server-lwtC1vaS.js

@@ -1,72 +0,0 @@
-import { t as createSubsystemLogger } from "./subsystem-B7U-DPv3.js";
-import { i as getRuntimeConfig } from "./io-T1CV3Z1L.js";
-import { r as setBridgeAuthForPort, t as deleteBridgeAuthForPort } from "./bridge-auth-registry-BX45MLkH.js";
-import { n as installBrowserAuthMiddleware, r as installBrowserCommonMiddleware } from "./server-middleware-KTpBWo-A.js";
-import { n as resolveBrowserConfig } from "./config-CFMbHJb0.js";
-import { n as resolveBrowserControlAuth, r as shouldAutoGenerateBrowserAuth, t as ensureBrowserControlAuth } from "./control-auth-DG_cw-aN.js";
-import { r as loadBrowserConfigForRuntimeRefresh } from "./server-context-BhiPROPA.js";
-import "./subsystem-C1kX1duw.js";
-import { t as registerBrowserRoutes } from "./routes-H185h3U-.js";
-import { a as stopBrowserControlRuntime, i as getBrowserControlState, n as createBrowserControlContext, r as ensureBrowserControlRuntime, t as isDefaultBrowserPluginEnabled } from "./plugin-enabled-CEIKWKrq.js";
-import express from "express";
-//#region extensions/browser/src/server.ts
-const logServer = createSubsystemLogger("browser").child("server");
-async function startBrowserControlServerFromConfig() {
-	const current = getBrowserControlState();
-	if (current?.server) return current;
-	const cfg = getRuntimeConfig();
-	const browserCfg = loadBrowserConfigForRuntimeRefresh();
-	if (!isDefaultBrowserPluginEnabled(browserCfg)) return null;
-	const resolved = resolveBrowserConfig(browserCfg.browser, browserCfg);
-	if (!resolved.enabled) return null;
-	let browserAuth = resolveBrowserControlAuth(cfg);
-	let browserAuthBootstrapFailed = false;
-	try {
-		const ensured = await ensureBrowserControlAuth({ cfg });
-		browserAuth = ensured.auth;
-		if (ensured.generatedToken) logServer.info("No browser auth configured; generated browser control auth credential automatically.");
-	} catch (err) {
-		logServer.warn(`failed to auto-configure browser auth: ${String(err)}`);
-		browserAuthBootstrapFailed = true;
-	}
-	if ((browserAuthBootstrapFailed || shouldAutoGenerateBrowserAuth(process.env)) && !browserAuth.token && !browserAuth.password) {
-		if (browserAuthBootstrapFailed) logServer.error("browser control startup aborted: authentication bootstrap failed and no fallback auth is configured.");
-		else logServer.error("browser control startup aborted: no authentication configured.");
-		return null;
-	}
-	const app = express();
-	installBrowserCommonMiddleware(app);
-	installBrowserAuthMiddleware(app, browserAuth);
-	registerBrowserRoutes(app, createBrowserControlContext());
-	const port = resolved.controlPort;
-	const server = await new Promise((resolve, reject) => {
-		const s = app.listen(port, "127.0.0.1", () => resolve(s));
-		s.once("error", reject);
-	}).catch((err) => {
-		logServer.error(`fengming browser server failed to bind 127.0.0.1:${port}: ${String(err)}`);
-		return null;
-	});
-	if (!server) return null;
-	const state = await ensureBrowserControlRuntime({
-		server,
-		port,
-		resolved,
-		owner: "server",
-		onWarn: (message) => logServer.warn(message)
-	});
-	setBridgeAuthForPort(port, browserAuth);
-	const authMode = browserAuth.token ? "token" : browserAuth.password ? "password" : "off";
-	logServer.info(`Browser control listening on http://127.0.0.1:${port}/ (auth=${authMode})`);
-	return state;
-}
-async function stopBrowserControlServer() {
-	const current = getBrowserControlState();
-	if (current?.port) deleteBridgeAuthForPort(current.port);
-	await stopBrowserControlRuntime({
-		requestedBy: "server",
-		closeServer: true,
-		onWarn: (message) => logServer.warn(message)
-	});
-}
-//#endregion
-export { startBrowserControlServerFromConfig, stopBrowserControlServer };

package/dist/server-methods-BY_ZqDFJ.js

@@ -1,497 +0,0 @@
-import { Ri as ErrorCodes, zi as errorShape } from "./src-B1Y482-m.js";
-import { i as gatewayStartupUnavailableDetails } from "./startup-unavailable-WFvkTNiD.js";
-import { r as getPluginRegistryState } from "./runtime-state-CeeLAkCy.js";
-import { n as createCoreGatewayMethodDescriptors, r as isCoreGatewayMethodClassified } from "./core-descriptors-B9yUgJ17.js";
-import { t as ADMIN_SCOPE } from "./operator-scopes-DGvgHuOd.js";
-import { n as authorizeOperatorScopesForMethod } from "./method-scopes-CTk-6mpm.js";
-import { i as createPluginGatewayMethodDescriptors, n as createGatewayMethodRegistry, t as createGatewayMethodDescriptorsFromHandlers } from "./registry-BQNtQhdh.js";
-import { n as withPluginRuntimeGatewayRequestScope } from "./gateway-request-scope-BHnIDss1.js";
-import { t as consumeControlPlaneWriteBudget } from "./control-plane-rate-limit-AYt-ugaJ.js";
-import { n as resolveControlPlaneActor, t as formatControlPlaneActor } from "./control-plane-audit-Ckq5Tcro.js";
-import { n as parseGatewayRole, t as isRoleAuthorizedForMethod } from "./role-policy-DLlx6KCe.js";
-//#region src/gateway/server-methods.ts
-function lazyHandlerModule(loadModule, selectHandlers) {
-	let handlersPromise = null;
-	return () => handlersPromise ??= loadModule().then(selectHandlers);
-}
-function createLazyCoreHandlers(params) {
-	return Object.fromEntries(params.methods.map((method) => [method, async (opts) => {
-		const handler = (await params.loadHandlers())[method];
-		if (!handler) throw new Error(`lazy gateway handler not found: ${method}`);
-		await handler(opts);
-	}]));
-}
-const loadAgentHandlers = lazyHandlerModule(() => import("./agent-WEb757bl.js"), (module) => module.agentHandlers);
-const loadAgentsHandlers = lazyHandlerModule(() => import("./agents-DCj3YP5G.js"), (module) => module.agentsHandlers);
-const loadArtifactsHandlers = lazyHandlerModule(() => import("./artifacts-CZ0iZ-ub.js"), (module) => module.artifactsHandlers);
-const loadChannelsHandlers = lazyHandlerModule(() => import("./channels--yf9pUlU.js"), (module) => module.channelsHandlers);
-const loadChatHandlers = lazyHandlerModule(() => import("./chat-BLA8ORQI.js"), (module) => module.chatHandlers);
-const loadCommandsHandlers = lazyHandlerModule(() => import("./commands-9VAmd3Tg.js"), (module) => module.commandsHandlers);
-const loadConfigHandlers = lazyHandlerModule(() => import("./config-NDmMuPNd.js"), (module) => module.configHandlers);
-const loadConnectHandlers = lazyHandlerModule(() => import("./connect-Dy_A4hjX.js"), (module) => module.connectHandlers);
-const loadCronHandlers = lazyHandlerModule(() => import("./cron-DI0JHhDS.js"), (module) => module.cronHandlers);
-const loadDeviceHandlers = lazyHandlerModule(() => import("./devices-BCeax19W.js"), (module) => module.deviceHandlers);
-const loadDiagnosticsHandlers = lazyHandlerModule(() => import("./diagnostics-DnZ9cS_d.js"), (module) => module.diagnosticsHandlers);
-const loadDoctorHandlers = lazyHandlerModule(() => import("./doctor-CaBlt19-.js"), (module) => module.doctorHandlers);
-const loadEnvironmentsHandlers = lazyHandlerModule(() => import("./environments-DYbJ1N0-.js"), (module) => module.environmentsHandlers);
-const loadExecApprovalsHandlers = lazyHandlerModule(() => import("./exec-approvals-ByWUCFQM.js"), (module) => module.execApprovalsHandlers);
-const loadHealthHandlers = lazyHandlerModule(() => import("./health-DstBJmcd.js"), (module) => module.healthHandlers);
-const loadLogsHandlers = lazyHandlerModule(() => import("./logs-BULiE3ir.js"), (module) => module.logsHandlers);
-const loadModelsAuthStatusHandlers = lazyHandlerModule(() => import("./models-auth-status-k6zMiB8P.js"), (module) => module.modelsAuthStatusHandlers);
-const loadModelsHandlers = lazyHandlerModule(() => import("./models-BDtD6dBG.js"), (module) => module.modelsHandlers);
-const loadNativeHookRelayHandlers = lazyHandlerModule(() => import("./native-hook-relay-DbigcfSz.js"), (module) => module.nativeHookRelayHandlers);
-const loadNodePendingHandlers = lazyHandlerModule(() => import("./nodes-pending-Cjg09MXz.js"), (module) => module.nodePendingHandlers);
-const loadNodeHandlers = lazyHandlerModule(() => import("./nodes-Dk4vOgg9.js"), (module) => module.nodeHandlers);
-const loadPluginHostHookHandlers = lazyHandlerModule(() => import("./plugin-host-hooks-Dar_329p.js"), (module) => module.pluginHostHookHandlers);
-const loadPushHandlers = lazyHandlerModule(() => import("./push-H4LWZ-TI.js"), (module) => module.pushHandlers);
-const loadRestartHandlers = lazyHandlerModule(() => import("./restart-D7iQ9WAq.js"), (module) => module.restartHandlers);
-const loadSendHandlers = lazyHandlerModule(() => import("./send-Q8hcka4X.js"), (module) => module.sendHandlers);
-const loadSessionsHandlers = lazyHandlerModule(() => import("./sessions-B-SkIoaa.js"), (module) => module.sessionsHandlers);
-const loadSkillsHandlers = lazyHandlerModule(() => import("./skills-wa1l1VHm.js"), (module) => module.skillsHandlers);
-const loadSystemHandlers = lazyHandlerModule(() => import("./system-CelaP2zI.js"), (module) => module.systemHandlers);
-const loadTalkHandlers = lazyHandlerModule(() => import("./talk-DGOI3Lu3.js"), (module) => module.talkHandlers);
-const loadTasksHandlers = lazyHandlerModule(() => import("./tasks-BgCy130M.js"), (module) => module.tasksHandlers);
-const loadToolsCatalogHandlers = lazyHandlerModule(() => import("./tools-catalog-PoLPJ-Iw.js"), (module) => module.toolsCatalogHandlers);
-const loadToolsEffectiveHandlers = lazyHandlerModule(() => import("./tools-effective-C2mHZT-A.js"), (module) => module.toolsEffectiveHandlers);
-const loadToolsInvokeHandlers = lazyHandlerModule(() => import("./tools-invoke-Ci6Rux2s.js"), (module) => module.toolsInvokeHandlers);
-const loadTtsHandlers = lazyHandlerModule(() => import("./tts-BLBgu1SV.js"), (module) => module.ttsHandlers);
-const loadUpdateHandlers = lazyHandlerModule(() => import("./update-D2HGBjGo.js"), (module) => module.updateHandlers);
-const loadUsageHandlers = lazyHandlerModule(() => import("./usage-DA9Pgy59.js"), (module) => module.usageHandlers);
-const loadVoicewakeRoutingHandlers = lazyHandlerModule(() => import("./voicewake-routing-Dt_nWwTX.js"), (module) => module.voicewakeRoutingHandlers);
-const loadVoicewakeHandlers = lazyHandlerModule(() => import("./voicewake-DBCtoMYX.js"), (module) => module.voicewakeHandlers);
-const loadWebHandlers = lazyHandlerModule(() => import("./web-CjW0W8-c.js"), (module) => module.webHandlers);
-const loadWizardHandlers = lazyHandlerModule(() => import("./wizard-0m4r2wsi.js"), (module) => module.wizardHandlers);
-function authorizeGatewayMethod(method, client, params) {
-	if (!client?.connect) return null;
-	if (method === "health") return null;
-	const roleRaw = client.connect.role ?? "operator";
-	const role = parseGatewayRole(roleRaw);
-	if (!role) return errorShape(ErrorCodes.INVALID_REQUEST, `unauthorized role: ${roleRaw}`);
-	const scopes = client.connect.scopes ?? [];
-	if (!isRoleAuthorizedForMethod(role, method)) return errorShape(ErrorCodes.INVALID_REQUEST, `unauthorized role: ${role}`);
-	if (role === "node") return null;
-	if (scopes.includes("operator.admin")) return null;
-	const scopeAuth = authorizeOperatorScopesForMethod(method, scopes, params);
-	if (!scopeAuth.allowed) return errorShape(ErrorCodes.INVALID_REQUEST, `missing scope: ${scopeAuth.missingScope}`);
-	return null;
-}
-const coreGatewayHandlers = {
-	...createLazyCoreHandlers({
-		methods: ["connect"],
-		loadHandlers: loadConnectHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["logs.tail"],
-		loadHandlers: loadLogsHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["voicewake.get", "voicewake.set"],
-		loadHandlers: loadVoicewakeHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["voicewake.routing.get", "voicewake.routing.set"],
-		loadHandlers: loadVoicewakeRoutingHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["health", "status"],
-		loadHandlers: loadHealthHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"channels.status",
-			"channels.start",
-			"channels.stop",
-			"channels.logout"
-		],
-		loadHandlers: loadChannelsHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"chat.history",
-			"chat.abort",
-			"chat.send",
-			"chat.inject"
-		],
-		loadHandlers: loadChatHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["commands.list"],
-		loadHandlers: loadCommandsHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"wake",
-			"cron.list",
-			"cron.status",
-			"cron.get",
-			"cron.add",
-			"cron.update",
-			"cron.remove",
-			"cron.run",
-			"cron.runs"
-		],
-		loadHandlers: loadCronHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"device.pair.list",
-			"device.pair.approve",
-			"device.pair.reject",
-			"device.pair.remove",
-			"device.token.rotate",
-			"device.token.revoke"
-		],
-		loadHandlers: loadDeviceHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["diagnostics.stability"],
-		loadHandlers: loadDiagnosticsHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"doctor.memory.status",
-			"doctor.memory.dreamDiary",
-			"doctor.memory.backfillDreamDiary",
-			"doctor.memory.resetDreamDiary",
-			"doctor.memory.resetGroundedShortTerm",
-			"doctor.memory.repairDreamingArtifacts",
-			"doctor.memory.dedupeDreamDiary",
-			"doctor.memory.remHarness"
-		],
-		loadHandlers: loadDoctorHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["environments.list", "environments.status"],
-		loadHandlers: loadEnvironmentsHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"exec.approvals.get",
-			"exec.approvals.set",
-			"exec.approvals.node.get",
-			"exec.approvals.node.set"
-		],
-		loadHandlers: loadExecApprovalsHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["web.login.start", "web.login.wait"],
-		loadHandlers: loadWebHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["models.list"],
-		loadHandlers: loadModelsHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["models.authLogout", "models.authStatus"],
-		loadHandlers: loadModelsAuthStatusHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["nativeHook.invoke"],
-		loadHandlers: loadNativeHookRelayHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["plugins.uiDescriptors", "plugins.sessionAction"],
-		loadHandlers: loadPluginHostHookHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"config.get",
-			"config.schema",
-			"config.schema.lookup",
-			"config.set",
-			"config.patch",
-			"config.apply",
-			"config.openFile"
-		],
-		loadHandlers: loadConfigHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"wizard.start",
-			"wizard.next",
-			"wizard.cancel",
-			"wizard.status"
-		],
-		loadHandlers: loadWizardHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"talk.session.create",
-			"talk.session.join",
-			"talk.session.appendAudio",
-			"talk.session.startTurn",
-			"talk.session.endTurn",
-			"talk.session.cancelTurn",
-			"talk.session.cancelOutput",
-			"talk.session.submitToolResult",
-			"talk.session.steer",
-			"talk.session.close",
-			"talk.client.create",
-			"talk.client.toolCall",
-			"talk.client.steer",
-			"talk.catalog",
-			"talk.config",
-			"talk.speak",
-			"talk.mode"
-		],
-		loadHandlers: loadTalkHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"tasks.list",
-			"tasks.get",
-			"tasks.cancel"
-		],
-		loadHandlers: loadTasksHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["tools.catalog"],
-		loadHandlers: loadToolsCatalogHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["tools.effective"],
-		loadHandlers: loadToolsEffectiveHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["tools.invoke"],
-		loadHandlers: loadToolsInvokeHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"tts.status",
-			"tts.enable",
-			"tts.disable",
-			"tts.convert",
-			"tts.setProvider",
-			"tts.personas",
-			"tts.setPersona",
-			"tts.providers"
-		],
-		loadHandlers: loadTtsHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"skills.upload.begin",
-			"skills.upload.chunk",
-			"skills.upload.commit",
-			"skills.status",
-			"skills.bins",
-			"skills.search",
-			"skills.detail",
-			"skills.securityVerdicts",
-			"skills.skillCard",
-			"skills.install",
-			"skills.update"
-		],
-		loadHandlers: loadSkillsHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"sessions.list",
-			"sessions.cleanup",
-			"sessions.subscribe",
-			"sessions.unsubscribe",
-			"sessions.messages.subscribe",
-			"sessions.messages.unsubscribe",
-			"sessions.preview",
-			"sessions.describe",
-			"sessions.resolve",
-			"sessions.compaction.list",
-			"sessions.compaction.get",
-			"sessions.create",
-			"sessions.compaction.branch",
-			"sessions.compaction.restore",
-			"sessions.send",
-			"sessions.steer",
-			"sessions.abort",
-			"sessions.patch",
-			"sessions.pluginPatch",
-			"sessions.reset",
-			"sessions.delete",
-			"sessions.get",
-			"sessions.compact"
-		],
-		loadHandlers: loadSessionsHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"gateway.identity.get",
-			"last-heartbeat",
-			"set-heartbeats",
-			"system-presence",
-			"system-event"
-		],
-		loadHandlers: loadSystemHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["update.status", "update.run"],
-		loadHandlers: loadUpdateHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"node.pair.request",
-			"node.pair.list",
-			"node.pair.approve",
-			"node.pair.reject",
-			"node.pair.remove",
-			"node.pair.verify",
-			"node.rename",
-			"node.list",
-			"node.describe",
-			"node.pluginSurface.refresh",
-			"node.pending.pull",
-			"node.pending.ack",
-			"node.invoke",
-			"node.invoke.result",
-			"node.event"
-		],
-		loadHandlers: loadNodeHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["node.pending.drain", "node.pending.enqueue"],
-		loadHandlers: loadNodePendingHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"push.test",
-			"push.web.vapidPublicKey",
-			"push.web.subscribe",
-			"push.web.unsubscribe",
-			"push.web.test"
-		],
-		loadHandlers: loadPushHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: ["gateway.restart.request", "gateway.restart.preflight"],
-		loadHandlers: loadRestartHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"message.action",
-			"send",
-			"poll"
-		],
-		loadHandlers: loadSendHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"usage.status",
-			"usage.cost",
-			"sessions.usage",
-			"sessions.usage.timeseries",
-			"sessions.usage.logs"
-		],
-		loadHandlers: loadUsageHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"agent",
-			"agent.identity.get",
-			"agent.wait"
-		],
-		loadHandlers: loadAgentHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"agents.list",
-			"agents.create",
-			"agents.update",
-			"agents.delete",
-			"agents.files.list",
-			"agents.files.get",
-			"agents.files.set"
-		],
-		loadHandlers: loadAgentsHandlers
-	}),
-	...createLazyCoreHandlers({
-		methods: [
-			"artifacts.list",
-			"artifacts.get",
-			"artifacts.download"
-		],
-		loadHandlers: loadArtifactsHandlers
-	})
-};
-function createRequestGatewayMethodRegistry(extraHandlers) {
-	const activePluginRegistry = getPluginRegistryState()?.activeRegistry;
-	const activePluginHandlers = activePluginRegistry?.gatewayHandlers ?? {};
-	const extraHandlerEntries = Object.entries(extraHandlers ?? {});
-	const pluginMethodNames = new Set(Object.keys(activePluginHandlers));
-	const coreDescriptorHandlers = { ...coreGatewayHandlers };
-	for (const [method, extraHandler] of extraHandlerEntries) if (!pluginMethodNames.has(method) && isCoreGatewayMethodClassified(method)) coreDescriptorHandlers[method] = extraHandler;
-	const coreDescriptors = createCoreGatewayMethodDescriptors(coreDescriptorHandlers);
-	for (const descriptor of coreDescriptors) {
-		const extraHandler = extraHandlers?.[descriptor.name];
-		if (extraHandler && !pluginMethodNames.has(descriptor.name)) descriptor.handler = extraHandler;
-	}
-	const coreMethodNames = new Set(coreDescriptors.map((descriptor) => descriptor.name));
-	const auxHandlers = Object.fromEntries(extraHandlerEntries.filter(([method]) => !pluginMethodNames.has(method) && !coreMethodNames.has(method)));
-	return createGatewayMethodRegistry([
-		...coreDescriptors,
-		...activePluginRegistry ? createPluginGatewayMethodDescriptors(activePluginRegistry) : [],
-		...createGatewayMethodDescriptorsFromHandlers({
-			handlers: auxHandlers,
-			owner: {
-				kind: "aux",
-				area: "gateway-extra"
-			},
-			defaultScope: ADMIN_SCOPE
-		})
-	]);
-}
-async function handleGatewayRequest(opts) {
-	const { req, respond, client, isWebchatConnect, context } = opts;
-	const methodRegistry = opts.methodRegistry ?? createRequestGatewayMethodRegistry(opts.extraHandlers);
-	const authError = authorizeGatewayMethod(req.method, client, req.params);
-	if (authError) {
-		respond(false, void 0, authError);
-		return;
-	}
-	if (context.unavailableGatewayMethods?.has(req.method)) {
-		respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, `${req.method} unavailable during gateway startup`, {
-			retryable: true,
-			retryAfterMs: 500,
-			details: {
-				...gatewayStartupUnavailableDetails(),
-				method: req.method
-			}
-		}));
-		return;
-	}
-	if (methodRegistry.isControlPlaneWrite(req.method)) {
-		const budget = consumeControlPlaneWriteBudget({ client });
-		if (!budget.allowed) {
-			const actor = resolveControlPlaneActor(client);
-			context.logGateway.warn(`control-plane write rate-limited method=${req.method} ${formatControlPlaneActor(actor)} retryAfterMs=${budget.retryAfterMs} key=${budget.key}`);
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, `rate limit exceeded for ${req.method}; retry after ${Math.ceil(budget.retryAfterMs / 1e3)}s`, {
-				retryable: true,
-				retryAfterMs: budget.retryAfterMs,
-				details: {
-					method: req.method,
-					limit: "3 per 60s"
-				}
-			}));
-			return;
-		}
-	}
-	const handler = methodRegistry.getHandler(req.method);
-	if (!handler) {
-		respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `unknown method: ${req.method}`));
-		return;
-	}
-	const invokeHandler = () => handler({
-		req,
-		params: req.params ?? {},
-		client,
-		isWebchatConnect,
-		respond,
-		context
-	});
-	await withPluginRuntimeGatewayRequestScope({
-		context,
-		client,
-		isWebchatConnect
-	}, invokeHandler);
-}
-//#endregion
-export { coreGatewayHandlers, handleGatewayRequest };