@mastra/code-sdk 1.2.0-alpha.10 → 1.2.0-alpha.13

package/dist/index.js

@@ -29,6 +29,7 @@ import { hasExplicitOMConfiguration } from "./onboarding/om-settings.js";
 import { getAvailableModePacks, getAvailableOmPacks, selectPreferredOMPack } from "./onboarding/packs.js";
 import { getToolCategory } from "./permissions.js";
 import { PluginManager } from "./plugins/manager.js";
+import { PluginSignalLane } from "./plugins/signal-lane.js";
 import { PlanRejectionAbortProcessor } from "./processors/plan-rejection-abort.js";
 import { stateSchema } from "./schema.js";
 import { mastraBrand } from "./theme-palette.js";
@@ -50,6 +51,7 @@ import { AgentController } from "@mastra/core/agent-controller";
 import { createCodingAgent } from "@mastra/core/coding-agent";
 import { PROVIDER_REGISTRY } from "@mastra/core/llm";
 import { Mastra } from "@mastra/core/mastra";
+import { defaultNotificationDeliveryDecision } from "@mastra/core/notifications";
 import { AgentsMDInjector, PrefillErrorHandler, ProviderHistoryCompat, StreamErrorRetryProcessor, isBadRequestError } from "@mastra/core/processors";
 import { RequestContext } from "@mastra/core/request-context";
 import { InMemoryHarness, MastraCompositeStore } from "@mastra/core/storage";
@@ -201,6 +203,7 @@ async function createMastraCodeAgentController(config) {
 	const homeDir = config?.homeDir ?? config?.initialState?.homeDir;
 	const configDir = config?.configDir ?? ".mastracode";
 	let activeSession;
+	let pluginRuntimeController;
 	if (configDir !== ".mastracode") validateConfigDirName(configDir);
 	try {
 		process.loadEnvFile(path.join(cwd, ".env"));
@@ -324,60 +327,126 @@ async function createMastraCodeAgentController(config) {
 		configDir,
 		homeDir
 	});
+	pluginManager?.setRuntime({
+		getController: () => pluginRuntimeController,
+		getActiveSession: () => activeSession
+	});
 	const loadedPlugins = pluginManager ? await pluginManager.reload() : [];
 	const pluginTools = pluginManager?.getPluginTools() ?? {};
 	const outcomeScorer = createOutcomeScorer();
 	const efficiencyScorer = createEfficiencyScorer();
+	const getNotificationStreamOptions = async ({ resourceId, threadId }) => {
+		const session = await controller.getSessionByResource(resourceId) ?? activeSession;
+		if (!session) return void 0;
+		const modeId = session.mode.get();
+		const defaultModeModelId = controller.listModes().find((mode) => mode.id === modeId)?.defaultModelId;
+		const modelId = session.model.get() || activeSession?.model.get() || defaultModeModelId || "";
+		const requestContext = new RequestContext();
+		const agentControllerContext = {
+			controllerId: controller.id,
+			state: session.state.get(),
+			getState: () => session.state.get(),
+			setState: (updates) => session.state.set(updates),
+			threadId,
+			resourceId,
+			session: {
+				id: session.identity.getId(),
+				ownerId: session.identity.getOwnerId(),
+				modeId,
+				modelId,
+				state: {
+					get: () => session.state.get(),
+					set: (updates) => session.state.set(updates),
+					update: (updater) => session.state.update(updater)
+				}
+			},
+			workspace: session.getWorkspace(),
+			getSubagentModelId: (params) => session.subagents.model.get(params ?? {})
+		};
+		requestContext.set("controller", agentControllerContext);
+		return {
+			memory: {
+				thread: threadId,
+				resource: resourceId
+			},
+			requestContext,
+			maxSteps: 1e3,
+			savePerStep: false,
+			requireToolApproval: session.state.get().yolo !== true,
+			modelSettings: { temperature: 1 }
+		};
+	};
 	const githubSignals = globalSettings.signals?.experimentalGithubSignals && !config?.disableGithubSignals ? new GithubSignals({
 		cwd: project.rootPath,
 		gitcrawlCommand: process.env.MASTRACODE_GITCRAWL_BIN ?? process.env.GITCRAWL_BIN ?? process.env.MASTRACODE_GITCRAWL_COMMAND ?? process.env.GITCRAWL_COMMAND,
-		getNotificationStreamOptions: async ({ resourceId, threadId }) => {
-			const session = await controller.getSessionByResource(resourceId) ?? activeSession;
-			const modeId = session.mode.get();
-			const defaultModeModelId = controller.listModes().find((mode) => mode.id === modeId)?.defaultModelId;
-			const modelId = session.model.get() || activeSession?.model.get() || defaultModeModelId || "";
-			const requestContext = new RequestContext();
-			const agentControllerContext = {
-				controllerId: controller.id,
-				state: session.state.get(),
-				getState: () => session.state.get(),
-				setState: (updates) => session.state.set(updates),
-				threadId,
-				resourceId,
-				session: {
-					id: session.identity.getId(),
-					ownerId: session.identity.getOwnerId(),
-					modeId,
-					modelId,
-					state: {
-						get: () => session.state.get(),
-						set: (updates) => session.state.set(updates),
-						update: (updater) => session.state.update(updater)
-					}
-				},
-				workspace: controller.getWorkspace(),
-				getSubagentModelId: (params) => session.subagents.model.get(params ?? {})
-			};
-			requestContext.set("controller", agentControllerContext);
-			return {
-				memory: {
-					thread: threadId,
-					resource: resourceId
-				},
-				requestContext,
-				maxSteps: 1e3,
-				savePerStep: false,
-				requireToolApproval: session.state.get().yolo !== true,
-				modelSettings: { temperature: 1 }
-			};
-		}
+		getNotificationStreamOptions
 	}) : void 0;
+	const mastraCodeInputProcessors = [
+		...config?.inputProcessors ?? [],
+		new PlanRejectionAbortProcessor(),
+		new AgentsMDInjector({
+			isEnabled: ({ requestContext }) => {
+				const state = getInjectorSessionState(requestContext);
+				return state?.untrustedCheckout !== true || typeof state?.baseRef === "string";
+			},
+			getReader: ({ requestContext }) => {
+				const state = getInjectorSessionState(requestContext);
+				if (state?.untrustedCheckout !== true || typeof state?.baseRef !== "string") return void 0;
+				return createGitRefReminderReader(state?.projectPath ?? project.rootPath, state.baseRef);
+			},
+			getIgnoredInstructionPaths: ({ requestContext }) => {
+				const state = getInjectorSessionState(requestContext);
+				const projectPath = state?.projectPath ?? project.rootPath;
+				return getStaticallyLoadedInstructionPaths(projectPath, void 0, state?.untrustedCheckout === true && typeof state?.baseRef === "string" ? createGitRefInstructionReader(projectPath, state.baseRef) : void 0);
+			}
+		}),
+		new ProviderHistoryCompat()
+	];
+	const taskSignalProvider = new TaskSignalProvider();
+	const NO_PLUGIN_PROCESSORS = {
+		input: [],
+		output: []
+	};
+	let pluginProcessorReadWarned = false;
+	const pluginSignalLane = pluginManager ? new PluginSignalLane({ reservedProviderIds: [taskSignalProvider.id, ...githubSignals ? [githubSignals.id] : []] }) : void 0;
+	let unsubscribePluginReload;
+	/**
+	* Plugin processors are read through a function so that enabling, disabling or
+	* updating a plugin takes effect on the next request rather than requiring a
+	* new agent. This runs before every LLM call, and also outside the request
+	* path when the Agent catalogues its configured processors — where a throw is
+	* swallowed into a debug log. So it only reads already-resolved state: no
+	* filesystem, no network, no construction, and it never throws.
+	*/
+	const readPluginProcessors = () => {
+		try {
+			return pluginManager?.getPluginProcessors() ?? NO_PLUGIN_PROCESSORS;
+		} catch (error) {
+			if (!pluginProcessorReadWarned) {
+				pluginProcessorReadWarned = true;
+				console.warn("Failed to read plugin processors:", error);
+			}
+			return NO_PLUGIN_PROCESSORS;
+		}
+	};
 	const codeAgent = createCodingAgent({
 		id: CODE_AGENT_ID,
 		name: "Code Agent",
 		workspace: void 0,
 		instructions: getDynamicInstructions,
 		model: (ctx) => getDynamicModel(ctx, config?.settingsPath),
+		notifications: { deliveryPolicy: { decide: async (input) => {
+			const decision = defaultNotificationDeliveryDecision(input);
+			if (!input.record.resourceId) return decision;
+			const streamOptions = await getNotificationStreamOptions({
+				resourceId: input.record.resourceId,
+				threadId: input.record.threadId
+			});
+			return streamOptions ? {
+				...decision,
+				streamOptions
+			} : decision;
+		} } },
 		tools: createDynamicTools(mcpManager, config?.extraTools, config?.disabledTools, storage, pluginTools),
 		hooks: createToolHooks(hookManager, config?.postToolObserver),
 		scorers: {
@@ -393,7 +462,7 @@ async function createMastraCodeAgentController(config) {
 				}
 			}
 		},
-		signals: [new TaskSignalProvider(), ...githubSignals ? [githubSignals] : []],
+		signals: [taskSignalProvider, ...githubSignals ? [githubSignals] : []],
 		goal: {
 			judge: (ctx) => getGoalJudgeModel(ctx, config?.settingsPath),
 			maxRuns: globalSettings.models.goalMaxTurns ?? 50,
@@ -401,27 +470,12 @@ async function createMastraCodeAgentController(config) {
 			prompt: DEFAULT_GOAL_JUDGE_PROMPT,
 			tools: getGoalJudgeTools
 		},
-		inputProcessors: [
-			...config?.inputProcessors ?? [],
-			new PlanRejectionAbortProcessor(),
-			new AgentsMDInjector({
-				isEnabled: ({ requestContext }) => {
-					const state = getInjectorSessionState(requestContext);
-					return state?.untrustedCheckout !== true || typeof state?.baseRef === "string";
-				},
-				getReader: ({ requestContext }) => {
-					const state = getInjectorSessionState(requestContext);
-					if (state?.untrustedCheckout !== true || typeof state?.baseRef !== "string") return void 0;
-					return createGitRefReminderReader(state?.projectPath ?? project.rootPath, state.baseRef);
-				},
-				getIgnoredInstructionPaths: ({ requestContext }) => {
-					const state = getInjectorSessionState(requestContext);
-					const projectPath = state?.projectPath ?? project.rootPath;
-					return getStaticallyLoadedInstructionPaths(projectPath, void 0, state?.untrustedCheckout === true && typeof state?.baseRef === "string" ? createGitRefInstructionReader(projectPath, state.baseRef) : void 0);
-				}
-			}),
-			new ProviderHistoryCompat()
+		inputProcessors: () => [
+			...mastraCodeInputProcessors,
+			...readPluginProcessors().input.map((entry) => entry.value),
+			...pluginSignalLane?.getInputProcessors() ?? []
 		],
+		outputProcessors: () => [...readPluginProcessors().output.map((entry) => entry.value), ...pluginSignalLane?.getOutputProcessors() ?? []],
 		errorProcessors: [
 			new ProviderHistoryCompat(),
 			new StreamErrorRetryProcessor({ matchers: [
@@ -570,6 +624,11 @@ async function createMastraCodeAgentController(config) {
 			release: releaseThreadLock
 		}
 	});
+	pluginRuntimeController = controller;
+	if (pluginSignalLane && pluginManager) {
+		pluginSignalLane.sync(pluginManager.getPluginSignalProviders());
+		unsubscribePluginReload = pluginManager.onReload(() => pluginSignalLane.sync(pluginManager.getPluginSignalProviders()));
+	}
 	return {
 		controller,
 		storage,
@@ -594,6 +653,55 @@ async function createMastraCodeAgentController(config) {
 		ownerId,
 		setActiveSession: (session) => {
 			activeSession = session;
+		},
+		/**
+		* Starts the signal providers contributed by plugins. Called by the
+		* composition layer once the controller is inited, because that is when a
+		* Mastra instance exists — a provider without one has no storage, and
+		* nothing else will hand it one: the Agent propagates Mastra only to the
+		* providers in its own `signals` array, which these deliberately are not in.
+		*/
+		startPluginSignalProviders: () => {
+			const mastra = controller.getMastra();
+			if (!pluginSignalLane || !mastra) return;
+			pluginSignalLane.setMastra(mastra, codeAgent);
+		},
+		/**
+		* Stops every plugin-contributed signal provider and stops listening for
+		* plugin reloads. The inverse of `startPluginSignalProviders`, for an
+		* embedder that is done with this controller: a `pluginManager` shared
+		* across controllers (`MastraCodeConfig.pluginManager`) outlives any one of
+		* them, so without this its providers keep polling and its reload listener
+		* keeps firing for a controller that is gone.
+		*/
+		stopPluginSignalProviders: () => {
+			unsubscribePluginReload?.();
+			unsubscribePluginReload = void 0;
+			pluginSignalLane?.stopAll();
+		},
+		/**
+		* Hands Mastra to the statically configured input processors.
+		*
+		* The Agent does this itself, but only for processors configured as a
+		* plain array (`Array.isArray` in `__registerMastra`). This lane is a
+		* function so plugins can contribute to it, which takes those processors
+		* out of that branch — including any an embedder passed as
+		* `config.inputProcessors`, some of which need Mastra to work at all
+		* (`CostGuardProcessor` reads observability storage there). Doing it here
+		* keeps that unchanged.
+		*
+		* Plugin processors are deliberately not included: they come and go with
+		* their plugin, and the registry keeps the first instance registered under
+		* an id forever, which would leave a retired instance behind. Plugins
+		* reach Mastra through `getController()` on the plugin context instead.
+		*/
+		registerConfiguredProcessorsWithMastra: () => {
+			const mastra = controller.getMastra();
+			if (!mastra) return;
+			for (const processor of mastraCodeInputProcessors) {
+				mastra.addProcessor(processor);
+				mastra.addProcessorConfiguration(processor, CODE_AGENT_ID, "input");
+			}
 		}
 	};
 }
@@ -646,6 +754,8 @@ async function bootLocalAgentController(config) {
 	const { controller, sessionId, ownerId } = base;
 	await controller.init();
 	await controller.getMastra()?.startWorkers();
+	base.registerConfiguredProcessorsWithMastra();
+	base.startPluginSignalProviders();
 	const session = await controller.createSession({
 		id: sessionId,
 		ownerId
@@ -723,6 +833,8 @@ async function prepareAgentControllerMount(config) {
 	const finalize = async () => {
 		await controller.init();
 		await controller.getMastra()?.startWorkers();
+		base.registerConfiguredProcessorsWithMastra();
+		base.startPluginSignalProviders();
 	};
 	return {
 		base,