@mastra/code-sdk 0.0.0-mastracode-cloud-20260706153555

package/dist/index.js

@@ -0,0 +1,712 @@
+import { createHash } from "node:crypto";
+import { hostname } from "node:os";
+import path from "node:path";
+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 {
+  AgentsMDInjector,
+  isBadRequestError,
+  PrefillErrorHandler,
+  ProviderHistoryCompat,
+  StreamErrorRetryProcessor
+} from "@mastra/core/processors";
+import { RequestContext } from "@mastra/core/request-context";
+import { TaskSignalProvider } from "@mastra/core/signals";
+import { InMemoryHarness, MastraCompositeStore } from "@mastra/core/storage";
+import { DEFAULT_GOAL_JUDGE_PROMPT } from "@mastra/core/tools";
+import { DuckDBStore } from "@mastra/duckdb";
+import { GithubSignals } from "@mastra/github-signals";
+import {
+  Observability,
+  MastraStorageExporter,
+  MastraPlatformExporter,
+  SensitiveDataFilter
+} from "@mastra/observability";
+import { getDynamicInstructions } from "./agents/instructions.js";
+import { getDynamicMemory } from "./agents/memory.js";
+import { createMastraCodeGateway, getDynamicModel, getGoalJudgeModel, resolveModel } from "./agents/model.js";
+import { buildMode } from "./agents/modes/build.js";
+import { fastMode } from "./agents/modes/explore.js";
+import { planMode } from "./agents/modes/plan.js";
+import { getStaticallyLoadedInstructionPaths } from "./agents/prompts/agent-instructions.js";
+import { attachOMThreadStatePersistence, restoreOMThreadStateForCurrentThread } from "./agents/thread-caveman-state.js";
+import { createDynamicTools, createToolHooks } from "./agents/tools.js";
+import { getDynamicWorkspace, getGoalJudgeTools } from "./agents/workspace.js";
+import { AuthStorage } from "./auth/storage.js";
+import { DEFAULT_CONFIG_DIR, validateConfigDirName } from "./constants.js";
+import { createOutcomeScorer, createEfficiencyScorer } from "./evals/scorers/index.js";
+import { HookManager } from "./hooks/index.js";
+import { createMcpManager } from "./mcp/index.js";
+import { getAvailableModePacks, getAvailableOmPacks } from "./onboarding/packs.js";
+import {
+  loadSettings,
+  MEMORY_GATEWAY_PROVIDER,
+  OBSERVABILITY_AUTH_PREFIX,
+  resolveModelDefaults,
+  resolveOmRoleModel,
+  saveSettings
+} from "./onboarding/settings.js";
+import { getToolCategory } from "./permissions.js";
+import { PluginManager } from "./plugins/manager.js";
+import { PlanRejectionAbortProcessor } from "./processors/plan-rejection-abort.js";
+import { createAmazonBedrockGateway } from "./providers/amazon-bedrock-gateway.js";
+import { setAuthStorage } from "./providers/claude-max.js";
+import { setAuthStorage as setGitHubCopilotAuthStorage } from "./providers/github-copilot.js";
+import { setAuthStorage as setOpenAIAuthStorage } from "./providers/openai-codex.js";
+import { stateSchema } from "./schema.js";
+import { mastraBrand } from "./theme-palette.js";
+import { syncGateways } from "./utils/gateway-sync.js";
+import {
+  detectProject,
+  getObservabilityDatabasePath,
+  getStorageConfig,
+  getResourceIdOverride
+} from "./utils/project.js";
+import { createSignalsPubSub } from "./utils/signals-pubsub.js";
+import { createStorage, createVectorStore } from "./utils/storage-factory.js";
+import { acquireThreadLock, releaseThreadLock } from "./utils/thread-lock.js";
+const CODE_AGENT_ID = "code-agent";
+const MASTRACODE_ECONNRESET_MAX_RETRIES = 2;
+const MASTRACODE_ECONNRESET_RETRY_INITIAL_DELAY_MS = 1e3;
+const MASTRACODE_ECONNRESET_RETRY_MAX_DELAY_MS = 3e4;
+const ECONNRESET_MESSAGE_PATTERN = /econnreset|socket hang up/i;
+function isECONNRESETError(error) {
+  if (!error) return false;
+  const code = typeof error === "object" && "code" in error ? error.code : void 0;
+  if (typeof code === "string" && code.toUpperCase() === "ECONNRESET") return true;
+  const message = error instanceof Error ? error.message : void 0;
+  if (typeof message === "string" && ECONNRESET_MESSAGE_PATTERN.test(message)) return true;
+  return false;
+}
+function shortHash(input) {
+  return createHash("sha256").update(input).digest("hex").slice(0, 12);
+}
+function applyEffectiveDefaultsToModes(modes, effectiveDefaults) {
+  return modes.map((mode) => {
+    const savedModel = effectiveDefaults[mode.id];
+    if (!savedModel) {
+      return mode;
+    }
+    return {
+      ...mode,
+      defaultModelId: savedModel
+    };
+  });
+}
+function addPluginToolsToModeAllowlists(modes, pluginToolNames) {
+  if (pluginToolNames.length === 0) return modes;
+  return modes.map((mode) => {
+    if (!mode.availableTools) return mode;
+    return {
+      ...mode,
+      availableTools: Array.from(/* @__PURE__ */ new Set([...mode.availableTools, ...pluginToolNames]))
+    };
+  });
+}
+function createAuthStorage() {
+  const authStorage = new AuthStorage();
+  setAuthStorage(authStorage);
+  setOpenAIAuthStorage(authStorage);
+  setGitHubCopilotAuthStorage(authStorage);
+  return authStorage;
+}
+function resolveCloudObservabilityConfig(settings, authStorage, resourceId) {
+  const resourceConfig = settings.observability.resources[resourceId];
+  if (resourceConfig) {
+    const token = authStorage.getStoredApiKey(`${OBSERVABILITY_AUTH_PREFIX}${resourceId}`);
+    if (token) {
+      return { accessToken: token, projectId: resourceConfig.projectId };
+    }
+  }
+  return {
+    accessToken: process.env.MASTRA_CLOUD_ACCESS_TOKEN,
+    projectId: process.env.MASTRA_PROJECT_ID
+  };
+}
+async function createMastraCodeAgentController(config) {
+  const cwd = config?.cwd ?? process.cwd();
+  const homeDir = config?.homeDir ?? config?.initialState?.homeDir;
+  const configDir = config?.configDir ?? DEFAULT_CONFIG_DIR;
+  let activeSession;
+  if (configDir !== DEFAULT_CONFIG_DIR) {
+    validateConfigDirName(configDir);
+  }
+  try {
+    process.loadEnvFile(path.join(cwd, ".env"));
+  } catch {
+  }
+  const authStorage = createAuthStorage();
+  const globalSettings = loadSettings(config?.settingsPath);
+  const storedGatewayKey = authStorage.getStoredApiKey(MEMORY_GATEWAY_PROVIDER);
+  const storedGatewayUrl = globalSettings.memoryGateway?.baseUrl;
+  if (storedGatewayKey) {
+    process.env["MASTRA_GATEWAY_API_KEY"] ??= storedGatewayKey;
+  }
+  if (storedGatewayUrl) {
+    process.env["MASTRA_GATEWAY_URL"] ??= storedGatewayUrl;
+  }
+  try {
+    const registry = PROVIDER_REGISTRY;
+    const providerEnvVars = {};
+    for (const [provider, cfg] of Object.entries(registry)) {
+      const envVars = cfg?.apiKeyEnvVar;
+      providerEnvVars[provider] = Array.isArray(envVars) ? envVars[0] : envVars;
+    }
+    providerEnvVars[MEMORY_GATEWAY_PROVIDER] ??= "MASTRA_GATEWAY_API_KEY";
+    authStorage.loadStoredApiKeysIntoEnv(providerEnvVars);
+  } catch {
+    authStorage.loadStoredApiKeysIntoEnv({
+      [MEMORY_GATEWAY_PROVIDER]: "MASTRA_GATEWAY_API_KEY",
+      anthropic: "ANTHROPIC_API_KEY",
+      openai: "OPENAI_API_KEY",
+      google: "GOOGLE_GENERATIVE_AI_API_KEY",
+      cerebras: "CEREBRAS_API_KEY",
+      deepseek: "DEEPSEEK_API_KEY"
+    });
+  }
+  const mgApiKey = process.env["MASTRA_GATEWAY_API_KEY"] ?? storedGatewayKey;
+  const mastraGatewayBaseUrl = (process.env["MASTRA_GATEWAY_URL"] ?? storedGatewayUrl ?? "https://gateway-api.mastra.ai").replace(/\/+$/, "").replace(/\/v1$/, "");
+  const mastraCodeGateway = createMastraCodeGateway({
+    mastraGatewayBaseUrl,
+    mastraGatewayApiKey: mgApiKey,
+    routeThroughMastraGateway: false,
+    settingsPath: config?.settingsPath
+  });
+  const amazonBedrockGateway = createAmazonBedrockGateway();
+  const project = detectProject(cwd);
+  const resourceIdOverride = getResourceIdOverride(project.rootPath, configDir);
+  if (resourceIdOverride) {
+    project.resourceId = resourceIdOverride;
+    project.resourceIdOverride = true;
+  }
+  const sessionId = `mastracode-session-${shortHash(project.resourceId)}`;
+  const ownerId = `mastracode-${shortHash(`${hostname()}\0${project.rootPath}`)}`;
+  const configuredPubSub = config?.pubsub;
+  const useUnixSocketPubSub = (config?.unixSocketPubSub ?? globalSettings.signals?.unixSocketPubSub ?? false) && process.platform !== "win32";
+  const signalsPubSub = configuredPubSub ?? (useUnixSocketPubSub ? createSignalsPubSub(project.resourceId) : void 0);
+  const crossProcessPubSub = config?.crossProcessPubSub ?? (!configuredPubSub && useUnixSocketPubSub);
+  if (crossProcessPubSub && !signalsPubSub) {
+    throw new Error("crossProcessPubSub requires a pubsub instance");
+  }
+  const storageConfig = config?.storage ?? getStorageConfig(project.rootPath, globalSettings.storage, configDir);
+  const storageResult = await createStorage(storageConfig);
+  const storageWarning = storageResult.warning;
+  let observabilityDomain;
+  let observabilityWarning;
+  if (globalSettings.observability.localTracing) {
+    try {
+      const observabilityDuckDB = new DuckDBStore({
+        id: "mastra-code-observability",
+        path: getObservabilityDatabasePath()
+      });
+      await observabilityDuckDB.db.getConnection();
+      observabilityDomain = observabilityDuckDB.observability;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const isLockError = /lock|locked|busy/i.test(message);
+      if (isLockError) {
+        observabilityWarning = "Observability unavailable \u2014 another MastraCode instance holds the database lock. Traces, scores, and feedback will not be recorded in this session.";
+      } else {
+        observabilityWarning = `Observability unavailable \u2014 DuckDB initialization failed: ${message}`;
+      }
+    }
+  }
+  const harnessStorage = new InMemoryHarness();
+  const storage = new MastraCompositeStore({
+    id: "mastra-code-storage",
+    default: storageResult.storage,
+    domains: {
+      ...observabilityDomain ? { observability: observabilityDomain } : {},
+      harness: harnessStorage
+    }
+  });
+  const observability = new Observability({
+    configs: {
+      default: {
+        serviceName: "mastracode",
+        // Only these requestContext keys are stored on spans — prevents leaking
+        // large objects (controller state, workspace, env vars) into trace data.
+        // Use dot-notation because these are nested inside the 'controller' key.
+        //
+        // Session identifiers:
+        //   threadId, resourceId, session.modeId, agentControllerId
+        // Environment & project:
+        //   state.projectName, state.gitBranch
+        // Model configuration:
+        //   session.modelId, state.subagentModelId
+        // Agent settings:
+        //   state.yolo, state.thinkingLevel, state.smartEditing
+        // Observational memory settings:
+        //   state.omScope, state.observerModelId, state.reflectorModelId,
+        //   state.observationThreshold, state.reflectionThreshold
+        requestContextKeys: [
+          // Session identifiers
+          "controller.threadId",
+          "controller.resourceId",
+          "controller.session.modeId",
+          "controller.controllerId",
+          // Environment & project
+          "controller.state.projectName",
+          "controller.state.gitBranch",
+          // Model configuration
+          "controller.session.modelId",
+          "controller.state.subagentModelId",
+          // Agent settings
+          "controller.state.yolo",
+          "controller.state.thinkingLevel",
+          "controller.state.smartEditing",
+          // Observational memory settings
+          "controller.state.omScope",
+          "controller.state.observerModelId",
+          "controller.state.reflectorModelId",
+          "controller.state.observationThreshold",
+          "controller.state.reflectionThreshold"
+        ],
+        exporters: [
+          // Only persist traces locally when DuckDB observability is available
+          // (via `/observability local on`). Without this guard the storage
+          // exporter falls through to the default libsql backend and silently
+          // fills the main database with gigabytes of span data.
+          ...observabilityDomain ? [new MastraStorageExporter({ strategy: "event-sourced" })] : [],
+          new MastraPlatformExporter(resolveCloudObservabilityConfig(globalSettings, authStorage, project.resourceId))
+        ],
+        spanOutputProcessors: [new SensitiveDataFilter()]
+      }
+    }
+  });
+  const vectorStore = await createVectorStore(storageConfig, storageResult.backend);
+  const memory = config?.memory === false ? void 0 : config?.memory ?? getDynamicMemory(storage, vectorStore);
+  const mcpManager = config?.disableMcp ? void 0 : createMcpManager(project.rootPath, configDir, config?.mcpServers);
+  const hookManager = config?.disableHooks ? void 0 : new HookManager(project.rootPath, "session-init", configDir, homeDir);
+  const pluginManager = config?.disablePlugins ? void 0 : config?.pluginManager ?? new PluginManager({ projectRoot: project.rootPath, configDir, homeDir });
+  const loadedPlugins = pluginManager ? await pluginManager.reload() : [];
+  const pluginTools = pluginManager?.getPluginTools() ?? {};
+  const outcomeScorer = createOutcomeScorer();
+  const efficiencyScorer = createEfficiencyScorer();
+  const githubSignals = globalSettings.signals?.experimentalGithubSignals ? 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 }
+      };
+    }
+  }) : void 0;
+  const codeAgent = createCodingAgent({
+    id: CODE_AGENT_ID,
+    name: "Code Agent",
+    // Workspace is wired per-request at the AgentController level (see
+    // `config.workspace` below), so opt out of the factory's default local
+    // workspace. An explicit `undefined` is required: the factory only builds a
+    // default when the `workspace` key is absent.
+    workspace: void 0,
+    instructions: getDynamicInstructions,
+    model: getDynamicModel,
+    tools: createDynamicTools(mcpManager, config?.extraTools, config?.disabledTools, storage, pluginTools),
+    hooks: createToolHooks(hookManager),
+    scorers: {
+      outcome: {
+        scorer: outcomeScorer,
+        sampling: { type: "none" }
+      },
+      efficiency: {
+        scorer: efficiencyScorer,
+        sampling: { type: "ratio", rate: 0.3 }
+      }
+    },
+    // TaskSignalProvider bundles the task tools + TaskStateProcessor: it merges
+    // the tools into the toolset and registers the task state-signal processor,
+    // so the task list persists across turns and survives OM truncation.
+    signals: [new TaskSignalProvider(), ...githubSignals ? [githubSignals] : []],
+    // Native goal mechanism: the in-loop goal step judges the thread's active
+    // objective each qualifying iteration. The judge model is required for any
+    // gating to occur; when unset the goal step is a complete no-op. A6 auto-wires
+    // the GoalStateProcessor so the `<current-objective>` signal persists across
+    // turns. Per-thread overrides live in the ThreadState `goal` record and win
+    // over these defaults.
+    goal: {
+      // Resolve the judge model through mastracode's gateway (a model-resolver
+      // function) so provider credentials are injected; returns undefined when no
+      // judge model is configured, keeping the goal step a no-op. Bind the same
+      // `settingsPath` used above so the judge model and `maxRuns` come from one
+      // config (a custom settings file would otherwise diverge).
+      judge: (ctx) => getGoalJudgeModel(ctx, config?.settingsPath),
+      maxRuns: globalSettings.models.goalMaxTurns ?? 50,
+      maxSteps: 1e3,
+      prompt: DEFAULT_GOAL_JUDGE_PROMPT,
+      // Read-only workspace tools the default goal judge may call to verify the
+      // agent's work against the actual filesystem (view, search_content,
+      // find_files, file_stat, lsp_inspect) rather than grading prose alone —
+      // restoring the original MastraCode judge's verification ability. Resolved
+      // per-request from the active workspace (mirrors `judge`).
+      tools: getGoalJudgeTools
+    },
+    inputProcessors: [
+      new PlanRejectionAbortProcessor(),
+      new AgentsMDInjector({
+        getIgnoredInstructionPaths: ({ requestContext }) => {
+          const agentControllerContext = requestContext?.get("controller");
+          const state = agentControllerContext?.getState();
+          return getStaticallyLoadedInstructionPaths(state?.projectPath ?? project.rootPath);
+        }
+      }),
+      new ProviderHistoryCompat()
+    ],
+    errorProcessors: [
+      new StreamErrorRetryProcessor({
+        matchers: [
+          { match: isBadRequestError, maxRetries: 1, delayMs: 2e3 },
+          {
+            match: isECONNRESETError,
+            maxRetries: MASTRACODE_ECONNRESET_MAX_RETRIES,
+            delayMs: ({ retryCount }) => Math.min(
+              MASTRACODE_ECONNRESET_RETRY_INITIAL_DELAY_MS * Math.pow(2, retryCount),
+              MASTRACODE_ECONNRESET_RETRY_MAX_DELAY_MS
+            )
+          }
+        ]
+      }),
+      new PrefillErrorHandler(),
+      new ProviderHistoryCompat()
+    ]
+  });
+  const defaultModes = [
+    {
+      ...buildMode,
+      metadata: {
+        ...buildMode.metadata,
+        color: mastraBrand.green
+      }
+    },
+    {
+      ...planMode,
+      metadata: {
+        ...planMode.metadata,
+        color: mastraBrand.purple
+      }
+    },
+    {
+      ...fastMode,
+      metadata: {
+        ...fastMode.metadata,
+        color: mastraBrand.orange
+      }
+    }
+  ];
+  const defaultIntervalHandlers = [
+    {
+      id: "gateway-sync",
+      intervalMs: 5 * 60 * 1e3,
+      immediate: false,
+      handler: () => syncGateways()
+    }
+  ];
+  const intervalHandlers = config?.intervalHandlers ?? defaultIntervalHandlers;
+  const anthropicCred = authStorage.get("anthropic");
+  const openaiCred = authStorage.get("openai-codex");
+  const githubCopilotCred = authStorage.get("github-copilot");
+  const startupAccess = {
+    anthropic: anthropicCred?.type === "oauth" ? "oauth" : anthropicCred?.type === "api_key" && anthropicCred.key.trim().length > 0 ? "apikey" : false,
+    openai: openaiCred?.type === "oauth" ? "oauth" : openaiCred?.type === "api_key" && openaiCred.key.trim().length > 0 ? "apikey" : false,
+    cerebras: process.env.CEREBRAS_API_KEY ? "apikey" : false,
+    google: process.env.GOOGLE_GENERATIVE_AI_API_KEY ? "apikey" : false,
+    deepseek: process.env.DEEPSEEK_API_KEY ? "apikey" : false,
+    "github-copilot": githubCopilotCred?.type === "oauth" ? "oauth" : false
+  };
+  if (mgApiKey) {
+    if (!startupAccess.anthropic) startupAccess.anthropic = "apikey";
+    if (!startupAccess.openai) startupAccess.openai = "apikey";
+  }
+  try {
+    const registry = PROVIDER_REGISTRY;
+    for (const [provider, config2] of Object.entries(registry)) {
+      if (startupAccess[provider] === "oauth" || startupAccess[provider] === "apikey") continue;
+      if (provider === "anthropic" || provider === "openai") continue;
+      const envVars = config2?.apiKeyEnvVar;
+      const envVarList = Array.isArray(envVars) ? envVars : envVars ? [envVars] : [];
+      if (envVarList.some((envVar) => process.env[envVar])) {
+        startupAccess[provider] = "apikey";
+      }
+    }
+  } catch {
+  }
+  const builtinPacks = getAvailableModePacks(startupAccess);
+  const builtinOmPacks = getAvailableOmPacks(startupAccess);
+  const effectiveDefaults = resolveModelDefaults(globalSettings, builtinPacks);
+  const effectiveObserverModel = resolveOmRoleModel(globalSettings, "observer", builtinOmPacks);
+  const effectiveReflectorModel = resolveOmRoleModel(globalSettings, "reflector", builtinOmPacks);
+  const effectiveObservationThreshold = globalSettings.models.omObservationThreshold ?? void 0;
+  const effectiveReflectionThreshold = globalSettings.models.omReflectionThreshold ?? void 0;
+  const effectiveCavemanObservations = globalSettings.models.omCavemanObservations ?? void 0;
+  const effectiveObserveAttachments = globalSettings.models.omObserveAttachments ?? "auto";
+  const modes = addPluginToolsToModeAllowlists(
+    applyEffectiveDefaultsToModes(config?.modes ? config.modes : defaultModes, effectiveDefaults),
+    Object.keys(pluginTools)
+  );
+  const defaultModeId = modes.find((mode) => mode.metadata?.default === true)?.id ?? modes.find((mode) => mode.id === "build")?.id ?? modes[0]?.id;
+  if (!defaultModeId) {
+    throw new Error("MastraCode requires at least one mode");
+  }
+  const globalInitialState = {};
+  if (effectiveObserverModel) {
+    globalInitialState.observerModelId = effectiveObserverModel;
+  }
+  if (effectiveReflectorModel) {
+    globalInitialState.reflectorModelId = effectiveReflectorModel;
+  }
+  if (effectiveObservationThreshold !== void 0) {
+    globalInitialState.observationThreshold = effectiveObservationThreshold;
+  }
+  if (effectiveReflectionThreshold !== void 0) {
+    globalInitialState.reflectionThreshold = effectiveReflectionThreshold;
+  }
+  if (effectiveCavemanObservations !== void 0) {
+    globalInitialState.cavemanObservations = effectiveCavemanObservations;
+  }
+  if (effectiveObserveAttachments !== void 0) {
+    globalInitialState.observeAttachments = effectiveObserveAttachments;
+  }
+  if (globalSettings.preferences.yolo !== null) {
+    globalInitialState.yolo = globalSettings.preferences.yolo;
+  }
+  globalInitialState.thinkingLevel = globalSettings.preferences.thinkingLevel;
+  if (config?.omScope) {
+    globalInitialState.omScope = config.omScope;
+  }
+  for (const [key, modelId] of Object.entries(globalSettings.models.subagentModels)) {
+    if (key === "default" || key === "_default") {
+      globalInitialState.subagentModelId = modelId;
+    } else {
+      globalInitialState[`subagentModelId_${key}`] = modelId;
+    }
+  }
+  const typedStateSchema = stateSchema;
+  const controller = new AgentController({
+    id: "mastra-code",
+    resourceId: project.resourceId,
+    storage,
+    observability,
+    memory,
+    pubsub: signalsPubSub,
+    stateSchema: typedStateSchema,
+    agent: codeAgent,
+    subagents: config?.subagents ?? [],
+    gateways: [amazonBedrockGateway, mastraCodeGateway],
+    workspace: config?.workspace ?? ((args) => getDynamicWorkspace(args)),
+    browser: config?.browser,
+    idGenerator: config?.idGenerator,
+    toolCategoryResolver: getToolCategory,
+    initialState: {
+      projectPath: project.rootPath,
+      projectName: project.name,
+      gitBranch: project.gitBranch,
+      pluginSkillPaths: loadedPlugins.flatMap((plugin) => plugin.status === "active" ? plugin.skillPaths ?? [] : []),
+      pluginCommandPaths: loadedPlugins.flatMap(
+        (plugin) => plugin.status === "active" ? plugin.commandPaths ?? [] : []
+      ),
+      pluginInstructions: loadedPlugins.flatMap(
+        (plugin) => plugin.status === "active" && plugin.instructions ? [plugin.instructions] : []
+      ),
+      yolo: true,
+      ...globalInitialState,
+      ...config?.initialState,
+      // configDir must always win over initialState spreads to stay in sync
+      // with MCP/hooks/storage which were already initialized with this value.
+      configDir
+    },
+    modes,
+    intervalHandlers,
+    modelUseCountProvider: () => loadSettings().modelUseCounts,
+    modelUseCountTracker: (modelId) => {
+      try {
+        const settings = loadSettings();
+        settings.modelUseCounts[modelId] = (settings.modelUseCounts[modelId] ?? 0) + 1;
+        saveSettings(settings);
+      } catch (error) {
+        console.error("Failed to persist model usage count", error);
+      }
+    },
+    threadLock: crossProcessPubSub ? void 0 : {
+      acquire: acquireThreadLock,
+      release: releaseThreadLock
+    }
+  });
+  return {
+    controller,
+    storage,
+    observability,
+    memory,
+    mcpManager,
+    hookManager,
+    pluginManager,
+    loadedPlugins,
+    pluginTools,
+    signalsPubSub,
+    authStorage,
+    resolveModel,
+    storageWarning,
+    observabilityWarning,
+    builtinPacks,
+    builtinOmPacks,
+    effectiveDefaults,
+    githubSignals,
+    // Identity for the single local session (Case 3). Servers ignore these and
+    // mint per-request sessions with client-supplied resourceIds instead.
+    sessionId,
+    ownerId,
+    // Lets the composition layer publish the created session back into the
+    // config closures (e.g. notification stream options read it lazily).
+    setActiveSession: (session) => {
+      activeSession = session;
+    }
+  };
+}
+async function wireSessionConcerns(base, session) {
+  const { hookManager, githubSignals } = base;
+  base.setActiveSession(session);
+  if (hookManager) {
+    session.subscribe((event) => {
+      if (event.type === "thread_changed") {
+        hookManager.setSessionId(event.threadId);
+      } else if (event.type === "thread_created") {
+        hookManager.setSessionId(event.thread.id);
+      }
+    });
+  }
+  if (githubSignals) {
+    const startGithubPollingForCurrentThread = async (threadId) => {
+      if (!threadId) return;
+      githubSignals.stopAllPolling();
+      try {
+        const threads = await session.thread.list({ allResources: true });
+        const thread = threads.find((item) => item.id === threadId);
+        await githubSignals.startPollingForThread(
+          {
+            threadId,
+            resourceId: thread?.resourceId ?? session.identity.getResourceId()
+          },
+          { pollImmediately: true }
+        );
+      } catch (error) {
+        console.warn("Failed to start GitHub PR polling:", error);
+      }
+    };
+    session.subscribe((event) => {
+      if (event.type === "thread_changed") void startGithubPollingForCurrentThread(event.threadId);
+      else if (event.type === "thread_created") void startGithubPollingForCurrentThread(event.thread.id);
+    });
+    void startGithubPollingForCurrentThread(session.thread.getId());
+  }
+  const omThreadStateSession = session;
+  attachOMThreadStatePersistence(omThreadStateSession);
+  await restoreOMThreadStateForCurrentThread(omThreadStateSession).catch(() => {
+  });
+}
+async function bootLocalAgentController(config) {
+  const base = await createMastraCodeAgentController(config);
+  const { controller, sessionId, ownerId } = base;
+  await controller.init();
+  await controller.getMastra()?.startWorkers();
+  const session = await controller.createSession({ id: sessionId, ownerId });
+  await wireSessionConcerns(base, session);
+  return { ...base, session };
+}
+async function mountAgentControllerOnMastra(config) {
+  const prepared = await prepareAgentControllerMount(config);
+  if (config?.mastra) {
+    prepared.base.controller.__registerMastra(config.mastra);
+    await prepared.finalize();
+    return { ...prepared.base, mastra: config.mastra };
+  }
+  const mastra = new Mastra(prepared.mastraArgs);
+  await prepared.finalize();
+  return { ...prepared.base, mastra };
+}
+async function prepareAgentControllerMount(config) {
+  const base = await createMastraCodeAgentController(config);
+  const { controller, storage, authStorage } = base;
+  const controllerId = config?.controllerId ?? controller.id;
+  const apiRoutes = config?.buildApiRoutes?.({ controller, authStorage });
+  const extraServerConfig = config?.buildServerConfig?.({ controller, authStorage });
+  const serverConfig = {
+    ...extraServerConfig,
+    ...apiRoutes?.length ? { apiRoutes } : {}
+  };
+  const mastraArgs = {
+    agentControllers: { [controllerId]: controller },
+    storage,
+    ...Object.keys(serverConfig).length ? { server: serverConfig } : {}
+  };
+  const finalize = async () => {
+    await controller.init();
+    await controller.getMastra()?.startWorkers();
+  };
+  return { base, mastraArgs, finalize };
+}
+const createMastraCode = bootLocalAgentController;
+import {
+  runMC,
+  runMCCli,
+  hasHeadlessFlag,
+  autoApprovePolicy,
+  denyPolicy,
+  permissionModeToPolicy,
+  formatHuman,
+  formatJsonl,
+  renderTextResult,
+  renderJsonResult
+} from "./headless/index.js";
+export {
+  autoApprovePolicy,
+  bootLocalAgentController,
+  createAuthStorage,
+  createMastraCode,
+  createMastraCodeAgentController,
+  denyPolicy,
+  formatHuman,
+  formatJsonl,
+  hasHeadlessFlag,
+  mountAgentControllerOnMastra,
+  permissionModeToPolicy,
+  prepareAgentControllerMount,
+  renderJsonResult,
+  renderTextResult,
+  runMC,
+  runMCCli,
+  wireSessionConcerns
+};
+//# sourceMappingURL=index.js.map